static void led_timer_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *) data;
struct timer_trig_data *timer_data = led_cdev->trigger_data;
unsigned long brightness = LED_OFF;
unsigned long delay = timer_data->delay_off;
if (!timer_data->delay_on || !timer_data->delay_off) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
if (!led_cdev->brightness) {
#ifndef CONFIG_MACH_CANOPUS
brightness = LED_FULL;
#else // CONFIG_MACH_CANOPUS
if (!timer_data->brightness)
brightness = LED_FULL;
else
brightness = timer_data->brightness;
#endif // CONFIG_MACH_CANOPUS
delay = timer_data->delay_on;
}
led_set_brightness(led_cdev, brightness);
mod_timer(&timer_data->timer, jiffies + msecs_to_jiffies(delay));
}
static void led_timer_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *) data;
struct timer_trig_data *timer_data = led_cdev->trigger_data;
unsigned long brightness;
unsigned long delay;
if (!timer_data->delay_on || !timer_data->delay_off) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
brightness = led_get_brightness(led_cdev);
if (!brightness) {
/* Time to switch the LED on. */
brightness = timer_data->brightness_on;
delay = timer_data->delay_on;
} else {
/* Store the current brightness value to be able
* to restore it when the delay_off period is over.
*/
timer_data->brightness_on = brightness;
brightness = LED_OFF;
delay = timer_data->delay_off;
}
led_set_brightness(led_cdev, brightness);
mod_timer(&timer_data->timer, jiffies + msecs_to_jiffies(delay));
}
static void led_timer_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *) data;
struct notification_trig_data *timer_data = led_cdev->trigger_data;
unsigned long brightness;
unsigned long delay;
if (!timer_data->delay_on || !timer_data->delay_off || !timer_data->blink_cnt) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
brightness = led_get_brightness(led_cdev);
if (!brightness) {
/* Time to switch the LED on. */
brightness = timer_data->brightness_on;
delay = timer_data->delay_on;
} else {
/* Store the current brightness value to be able
* to restore it when the delay_off period is over.
*/
timer_data->brightness_on = brightness;
brightness = LED_OFF;
delay = timer_data->delay_off;
if(timer_data->blink_cnt <= ++timer_data->current_blink_cnt) {
timer_data->current_blink_cnt = 0;
delay+=timer_data->off_duration;
}
}
led_set_brightness(led_cdev, brightness);
led_rtc_set_alarm(led_cdev, delay);
}
static void led_timer_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *) data;
struct timer_trig_data *timer_data = led_cdev->trigger_data;
unsigned long brightness;
unsigned long delay;
if (!timer_data->delay_on || !timer_data->delay_off) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
brightness = led_get_brightness(led_cdev);
if (!brightness) {
/* Time to switch the LED on. */
brightness = timer_data->brightness_on;
delay = timer_data->delay_on;
} else {
/* Store the current brightness value to be able
* to restore it when the delay_off period is over.
*/
timer_data->brightness_on = brightness;
brightness = LED_OFF;
delay = timer_data->delay_off;
}
led_set_brightness(led_cdev, brightness);
#if (CONFIG_RTC_LEDTRIG_TIMER==1)
led_rtc_set_alarm(led_cdev, delay);
#elif (CONFIG_RTC_LEDTRIG_TIMER==2)
hrtimer_start(&timer_data->hrtimer, ns_to_ktime((u64)delay*1000*1000), HRTIMER_MODE_REL);
#else
mod_timer(&timer_data->timer, jiffies + msecs_to_jiffies(delay));
#endif
}
static void led_timer_function(unsigned long data)
{
struct led_classdev *led_cdev = (void *)data;
unsigned long brightness;
unsigned long delay;
if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
brightness = led_get_brightness(led_cdev);
if (!brightness) {
/* */
brightness = led_cdev->blink_brightness;
delay = led_cdev->blink_delay_on;
} else {
/*
*/
led_cdev->blink_brightness = brightness;
brightness = LED_OFF;
delay = led_cdev->blink_delay_off;
}
led_set_brightness(led_cdev, brightness);
mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
}
static void set_baseline_state(struct led_netdev_data *trigger_data)
{
if ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up)
led_set_brightness(trigger_data->led_cdev, LED_FULL);
else
led_set_brightness(trigger_data->led_cdev, LED_OFF);
if ((trigger_data->mode & (MODE_TX | MODE_RX)) != 0 && trigger_data->link_up)
schedule_delayed_work(&trigger_data->work, trigger_data->interval);
}
static void set_baseline_state(struct led_netdev_data *trigger_data)
{
if ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up)
led_set_brightness(trigger_data->led_cdev, LED_FULL);
else
led_set_brightness(trigger_data->led_cdev, LED_OFF);
if ((trigger_data->mode & (MODE_TX | MODE_RX)) != 0 && trigger_data->link_up)
mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
}
static void usbdev_trig_update_state(struct usbdev_trig_data *td)
{
if (td->usb_dev)
led_set_brightness(td->led_cdev, LED_FULL);
else
led_set_brightness(td->led_cdev, LED_OFF);
if (td->interval && td->usb_dev)
mod_timer(&td->timer, jiffies + td->interval);
else
del_timer(&td->timer);
}
/* here's the real work! */
static void netdev_trig_timer(unsigned long arg)
{
struct led_netdev_data *trigger_data = (struct led_netdev_data *)arg;
const struct net_device_stats *dev_stats;
unsigned new_activity;
struct rtnl_link_stats64 temp;
write_lock(&trigger_data->lock);
if (!trigger_data->link_up || !trigger_data->net_dev || (trigger_data->mode & (MODE_TX | MODE_RX)) == 0) {
/* we don't need to do timer work, just reflect link state. */
led_set_brightness(trigger_data->led_cdev, ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up) ? LED_FULL : LED_OFF);
goto no_restart;
}
dev_stats = dev_get_stats(trigger_data->net_dev,&temp);
new_activity =
((trigger_data->mode & MODE_TX) ? dev_stats->tx_packets : 0) +
((trigger_data->mode & MODE_RX) ? dev_stats->rx_packets : 0);
if (trigger_data->mode & MODE_LINK) {
/* base state is ON (link present) */
/* if there's no link, we don't get this far and the LED is off */
/* OFF -> ON always */
/* ON -> OFF on activity */
if (trigger_data->led_cdev->brightness == LED_OFF) {
led_set_brightness(trigger_data->led_cdev, LED_FULL);
} else if (trigger_data->last_activity != new_activity) {
led_set_brightness(trigger_data->led_cdev, LED_OFF);
}
} else {
/* base state is OFF */
/* ON -> OFF always */
/* OFF -> ON on activity */
if (trigger_data->led_cdev->brightness == LED_FULL) {
led_set_brightness(trigger_data->led_cdev, LED_OFF);
} else if (trigger_data->last_activity != new_activity) {
led_set_brightness(trigger_data->led_cdev, LED_FULL);
}
}
trigger_data->last_activity = new_activity;
mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
no_restart:
write_unlock(&trigger_data->lock);
}
static void led_heartbeat_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *) data;
struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data;
unsigned long brightness = LED_OFF;
unsigned long delay = 0;
if (unlikely(panic_heartbeats)) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
/* acts like an actual heart beat -- ie thump-thump-pause... */
switch (heartbeat_data->phase) {
case 0:
/*
* The hyperbolic function below modifies the
* heartbeat period length in dependency of the
* current (1min) load. It goes through the points
* f(0)=1260, f(1)=860, f(5)=510, f(inf)->300.
*/
heartbeat_data->period = 300 +
(6720 << FSHIFT) / (5 * avenrun[0] + (7 << FSHIFT));
heartbeat_data->period =
msecs_to_jiffies(heartbeat_data->period);
delay = msecs_to_jiffies(70);
heartbeat_data->phase++;
brightness = led_cdev->max_brightness;
break;
case 1:
delay = heartbeat_data->period / 4 - msecs_to_jiffies(70);
heartbeat_data->phase++;
break;
case 2:
delay = msecs_to_jiffies(70);
heartbeat_data->phase++;
brightness = led_cdev->max_brightness;
break;
default:
delay = heartbeat_data->period - heartbeat_data->period / 4 -
msecs_to_jiffies(70);
heartbeat_data->phase = 0;
break;
}
led_set_brightness(led_cdev, brightness);
mod_timer(&heartbeat_data->timer, jiffies + delay);
}
static void led_set_software_blink(struct led_classdev *led_cdev,
unsigned long delay_on,
unsigned long delay_off)
{
int current_brightness;
current_brightness = led_get_brightness(led_cdev);
if (current_brightness)
led_cdev->blink_brightness = current_brightness;
if (!led_cdev->blink_brightness)
led_cdev->blink_brightness = led_cdev->max_brightness;
if (led_get_trigger_data(led_cdev) &&
delay_on == led_cdev->blink_delay_on &&
delay_off == led_cdev->blink_delay_off)
return;
led_stop_software_blink(led_cdev);
led_cdev->blink_delay_on = delay_on;
led_cdev->blink_delay_off = delay_off;
/* never on - don't blink */
if (!delay_on)
return;
/* never off - just set to brightness */
if (!delay_off) {
led_set_brightness(led_cdev, led_cdev->blink_brightness);
return;
}
mod_timer(&led_cdev->blink_timer, jiffies + 1);
}
static ssize_t led_brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
ssize_t ret = -EINVAL;
char *after;
unsigned long state = simple_strtoul(buf, &after, 10);
size_t count = after - buf;
if (isspace(*after))
count++;
if (count == size) {
ret = count;
/*if (state == LED_OFF)
led_trigger_remove(led_cdev);*/
if (1 == lcd_force_flag){
return ret;
}
led_set_brightness(led_cdev, state);
}
return ret;
}
/**
* led_classdev_unregister - unregisters a object of led_properties class.
* @led_cdev: the led device to unregister
*
* Unregisters a previously registered via led_classdev_register object.
*/
void led_classdev_unregister(struct led_classdev *led_cdev)
{
#ifdef CONFIG_LEDS_TRIGGERS
down_write(&led_cdev->trigger_lock);
if (led_cdev->trigger)
led_trigger_set(led_cdev, NULL);
up_write(&led_cdev->trigger_lock);
#endif
led_cdev->flags |= LED_UNREGISTERING;
/* Stop blinking */
led_stop_software_blink(led_cdev);
led_set_brightness(led_cdev, LED_OFF);
flush_work(&led_cdev->set_brightness_work);
device_unregister(led_cdev->dev);
down_write(&leds_list_lock);
list_del(&led_cdev->node);
up_write(&leds_list_lock);
mutex_destroy(&led_cdev->led_access);
}
static ssize_t brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
unsigned long state;
ssize_t ret;
mutex_lock(&led_cdev->led_access);
if (led_sysfs_is_disabled(led_cdev)) {
ret = -EBUSY;
goto unlock;
}
ret = kstrtoul(buf, 10, &state);
if (ret)
goto unlock;
if (state == LED_OFF)
led_trigger_remove(led_cdev);
led_set_brightness(led_cdev, state);
ret = size;
unlock:
mutex_unlock(&led_cdev->led_access);
return ret;
}
static void fb_f1c500s_resume(struct device_t * dev)
{
struct framebuffer_t * fb = (struct framebuffer_t *)dev->priv;
struct fb_f1c500s_pdata_t * pdat = (struct fb_f1c500s_pdata_t *)fb->priv;
led_set_brightness(pdat->backlight, pdat->brightness);
}
static ssize_t led_max_brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
ssize_t ret = -EINVAL;
unsigned long state = 0;
#ifdef CONFIG_LGE_PM //Control LCD brightness by one channel
static int prev_max_brightness = 255;
#endif
ret = strict_strtoul(buf, 10, &state);
if (!ret) {
ret = size;
if (state > LED_FULL)
state = LED_FULL;
led_cdev->max_brightness = state;
#ifdef CONFIG_LGE_PM //Control LCD brightness by one channel
if (prev_max_brightness != led_cdev->max_brightness)
{
kobject_uevent(&led_cdev->dev->kobj, KOBJ_CHANGE);
}
prev_max_brightness = led_cdev->max_brightness;
#else // QCT
led_set_brightness(led_cdev, led_cdev->brightness);
#endif
}
return ret;
}
static void fb_rk3288_resume(struct device_t * dev)
{
struct fb_t * fb = (struct fb_t *)dev->priv;
struct fb_rk3288_pdata_t * pdat = (struct fb_rk3288_pdata_t *)fb->priv;
led_set_brightness(pdat->backlight, pdat->brightness);
}
static ssize_t led_brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
ssize_t ret = -EINVAL;
char *after;
unsigned long state = simple_strtoul(buf, &after, 10);
size_t count = after - buf;
#ifdef CONFIG_LEDS_PM8226_EMOTIONAL
if(lge_get_boot_mode() != LGE_BOOT_MODE_CHARGERLOGO) {
if (!strncmp(led_cdev->name, "red", 3)){
change_led_mode();
}
}
#endif
if (isspace(*after))
count++;
if (count == size) {
ret = count;
if (state == LED_OFF)
led_trigger_remove(led_cdev);
led_set_brightness(led_cdev, state);
}
return ret;
}
static ssize_t led_br_maintain_on_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
int state = simple_strtol(buf, NULL, 10);
if (state){
printk(KERN_ERR "[pwr_led]: SYSFS_LED br_maintain_on trigger is 1!\n");
led_set_brightness(led_cdev, 255);
led_cdev->br_maintain_trigger = 1;
} else{
printk(KERN_ERR "[pwr_led]: SYSFS_LED br_maintain_on trigger is 0!\n");
led_cdev->br_maintain_trigger = 0;
led_set_brightness(led_cdev, 0);
}
return size;
}
static void fb_f1c500s_suspend(struct device_t * dev)
{
struct framebuffer_t * fb = (struct framebuffer_t *)dev->priv;
struct fb_f1c500s_pdata_t * pdat = (struct fb_f1c500s_pdata_t *)fb->priv;
pdat->brightness = led_get_brightness(pdat->backlight);
led_set_brightness(pdat->backlight, 0);
}
static ssize_t led_write_brightness(struct kobj_t * kobj, void * buf, size_t size)
{
struct led_t * led = (struct led_t *)kobj->priv;
int brightness = strtol(buf, NULL, 0);
led_set_brightness(led, brightness);
return size;
}
static void fb_rk3288_suspend(struct device_t * dev)
{
struct fb_t * fb = (struct fb_t *)dev->priv;
struct fb_rk3288_pdata_t * pdat = (struct fb_rk3288_pdata_t *)fb->priv;
pdat->brightness = led_get_brightness(pdat->backlight);
led_set_brightness(pdat->backlight, 0);
}
static int ledtrig_general_timer_function(struct timer_t * timer, void * data)
{
struct ledtrig_t * trigger = (struct ledtrig_t *)(data);
struct ledtrig_general_pdata_t * pdat = (struct ledtrig_general_pdata_t *)trigger->priv;
if(pdat->last_activity != pdat->activity)
{
pdat->last_activity = pdat->activity;
led_set_brightness(pdat->led, CONFIG_MAX_BRIGHTNESS);
timer_forward_now(timer, ms_to_ktime(20));
return 1;
}
else
{
led_set_brightness(pdat->led, 0);
return 0;
}
}
static ssize_t led_brightness_off_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
led_set_brightness(led_cdev, 0);
return sprintf(buf, "%u\n", 0);
}
/* here's the real work! */
static void netdev_trig_work(struct work_struct *work)
{
struct led_netdev_data *trigger_data = container_of(work, struct led_netdev_data, work.work);
struct rtnl_link_stats64 *dev_stats;
unsigned new_activity;
struct rtnl_link_stats64 temp;
if (!trigger_data->link_up || !trigger_data->net_dev || (trigger_data->mode & (MODE_TX | MODE_RX)) == 0) {
/* we don't need to do timer work, just reflect link state. */
led_set_brightness(trigger_data->led_cdev, ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up) ? LED_FULL : LED_OFF);
return;
}
dev_stats = dev_get_stats(trigger_data->net_dev, &temp);
new_activity =
((trigger_data->mode & MODE_TX) ? dev_stats->tx_packets : 0) +
((trigger_data->mode & MODE_RX) ? dev_stats->rx_packets : 0);
if (trigger_data->mode & MODE_LINK) {
/* base state is ON (link present) */
/* if there's no link, we don't get this far and the LED is off */
/* OFF -> ON always */
/* ON -> OFF on activity */
if (trigger_data->led_cdev->brightness == LED_OFF) {
led_set_brightness(trigger_data->led_cdev, LED_FULL);
} else if (trigger_data->last_activity != new_activity) {
led_set_brightness(trigger_data->led_cdev, LED_OFF);
}
} else {
/* base state is OFF */
/* ON -> OFF always */
/* OFF -> ON on activity */
if (trigger_data->led_cdev->brightness == LED_FULL) {
led_set_brightness(trigger_data->led_cdev, LED_OFF);
} else if (trigger_data->last_activity != new_activity) {
led_set_brightness(trigger_data->led_cdev, LED_FULL);
}
}
trigger_data->last_activity = new_activity;
schedule_delayed_work(&trigger_data->work, trigger_data->interval);
}
static void timer_trig_deactivate(struct led_classdev *led_cdev)
{
if (led_cdev->activated) {
device_remove_file(led_cdev->dev, &dev_attr_delay_on);
device_remove_file(led_cdev->dev, &dev_attr_delay_off);
led_cdev->activated = false;
}
/* Stop blinking */
led_set_brightness(led_cdev, LED_OFF);
}
static void led_timer_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *) data;
struct timer_trig_data *timer_data = led_cdev->trigger_data;
unsigned long brightness = LED_OFF;
unsigned long delay = timer_data->delay_off;
if (!timer_data->delay_on || !timer_data->delay_off) {
led_set_brightness(led_cdev, LED_OFF);
return;
}
if (!led_cdev->brightness) {
brightness = LED_FULL;
delay = timer_data->delay_on;
}
led_set_brightness(led_cdev, brightness);
mod_timer(&timer_data->timer, jiffies + msecs_to_jiffies(delay));
}
static ssize_t led_brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
ssize_t ret = -EINVAL;
char *after;
unsigned long state = simple_strtoul(buf, &after, 10);
size_t count = after - buf;
//ASUS_BSP +++ Maggie Lee "Backlight Porting"
led_debug(NO_DEBUG, "[BL] %s +++: led_cdev = %s value = %d\n", __func__, led_cdev->name, (int)state);
#ifdef CONFIG_ASUS_BACKLIGHT
g_brightness = state;
#endif
//ASUS_BSP --- Maggie Lee "Backlight Porting"
if (isspace(*after))
count++;
if (count == size) {
ret = count;
if (state == LED_OFF)
led_trigger_remove(led_cdev);
//ASUS_BSP +++ Maggie Lee "Backlight Porting"
#ifdef CONFIG_ASUS_BACKLIGHT
if (!strcmp(led_cdev->name, "lcd-backlight")) {
led_cdev->brightness = state;
asus_set_bl_brightness(state);
}
else
led_set_brightness(led_cdev, state);
#else
led_set_brightness(led_cdev, state);
#endif
//ASUS_BSP --- Maggie Lee "Backlight Porting"
}
return ret;
}
static void
led_dim_function(unsigned long data)
{
struct led_classdev *led_cdev = (struct led_classdev *)data;
struct dim_trig_data *dim_data = led_cdev->trigger_data;
unsigned int brightness;
brightness = ((LED_FULL - LED_OFF) * avenrun[0]) / EXP_1;
if (brightness > LED_FULL)
brightness = LED_FULL;
led_set_brightness(led_cdev, brightness);
mod_timer(&dim_data->timer, jiffies + msecs_to_jiffies(500));
}
static void gpio_trig_work(struct work_struct *work)
{
struct gpio_trig_data *gpio_data = container_of(work,
struct gpio_trig_data, work);
int tmp;
if (!gpio_data->gpio)
return;
tmp = gpio_get_value(gpio_data->gpio);
if (gpio_data->inverted)
tmp = !tmp;
if (tmp) {
if (gpio_data->desired_brightness)
led_set_brightness(gpio_data->led,
gpio_data->desired_brightness);
else
led_set_brightness(gpio_data->led, LED_FULL);
} else {
led_set_brightness(gpio_data->led, LED_OFF);
}
}
