/* input: intensity in percentage 0% - 100% */
static int ktd_backlight_update_status(struct backlight_device *bd)
{
int user_intensity = bd->props.brightness;
int tune_level = 0;
int i;
BLDBG("[BACKLIGHT] update_status ==> user_intensity : %d\n",
user_intensity);
#if CABC_FEATURE_ON
g_bl.props.brightness = user_intensity;
#endif
current_intensity = user_intensity;
if (bd->props.power != FB_BLANK_UNBLANK)
user_intensity = 0;
if (bd->props.fb_blank != FB_BLANK_UNBLANK)
user_intensity = 0;
if (bd->props.state & BL_CORE_SUSPENDED)
printk("[BACKLIGHT] update_status ==> user_intensity : %d\n",
user_intensity);
if (backlight_mode != BACKLIGHT_RESUME) {
BLDBG("[BACKLIGHT] suspend mode %d\n", backlight_mode);
return 0;
}
if(user_intensity > 0) {
if(user_intensity < MIN_BRIGHTNESS_VALUE) {
tune_level = DIMMING_VALUE; //DIMMING
} else if (user_intensity == MAX_BRIGHTNESS_VALUE) {
tune_level = brt_table[MAX_BRT_STAGE-1].tune_level;
} else {
for(i = 0; i < MAX_BRT_STAGE; i++) {
if(user_intensity <= brt_table[i].level ) {
tune_level = brt_table[i].tune_level;
break;
}
}
}
}
BLDBG("[BACKLIGHT] update_status ==> tune_level : %d\n", tune_level);
if (user_intensity >= 0) {
lcd_backlight_control(tune_level);
}
return 0;
}
void lcd_backlight_control(int level)
{
int i, set_bit;
unsigned long flags;
if(0 == level ){
BLDBG("[BACKLIGHT] backlight brightness level == 0\n");
gpio_set_value(backlight_pin, 0);
return;
}
if(0 == lcd_exist ){
BLDBG("[BACKLIGHT] LCD panel does not exist.\n");
gpio_set_value(backlight_pin, 0);
return;
}
spin_lock_irqsave(&bl_ctrl_lock, flags);
if(0 == gpio_get_value(backlight_pin)){
gpio_set_value(backlight_pin, 1);
udelay(140);
gpio_set_value(backlight_pin, 0);
udelay(260);
gpio_set_value(backlight_pin, 1);
udelay(10);
}else{
gpio_set_value(backlight_pin, 1);
//udelay(40);
}
BLDBG("Level %0x\n", level);
for (i = 7; i >= 0; i--) {
set_bit = ((level) & ((1<<i)))>>(i);
if (set_bit) {
gpio_set_value(backlight_pin, 0);
udelay(10);
gpio_set_value(backlight_pin, 1);
udelay(20);
} else {
gpio_set_value(backlight_pin, 0);
udelay(20);
gpio_set_value(backlight_pin, 1);
udelay(10);
}
}
gpio_set_value(backlight_pin, 0);
udelay(4);
gpio_set_value(backlight_pin, 1);
//udelay(400);
spin_unlock_irqrestore(&bl_ctrl_lock, flags);
}
static void ktd_backlight_shutdown(struct platform_device *pdev)
{
BLDBG("[BACKLIGHT] ktd_backlight_shutdown\n");
gpio_set_value(backlight_pin, 0);
mdelay(3);
}
static ssize_t auto_brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct lcd_info *lcd = dev_get_drvdata(dev);
int value;
int rc;
BLDBG("auto_brightness_store called\n");
rc = strict_strtoul(buf, (unsigned int)0, (unsigned long *)&value);
if (rc < 0)
return rc;
else {
if (lcd->auto_brightness != value) {
dev_info(dev, "%s - %d, %d\n", __func__,
lcd->auto_brightness, value);
lcd->auto_brightness = value;
if (lcd->auto_brightness == 0) {
cabc_status = 0;
backlight_cabc_off();
} else if (lcd->auto_brightness >= 1
&& lcd->auto_brightness < 5) {
cabc_status = 1;
backlight_cabc_on();
} else if (lcd->auto_brightness >= 5) {
cabc_status = 0;
backlight_cabc_off();
}
}
}
return size;
}
static void ktd_backlight_lateresume(struct early_suspend *desc)
{
struct ktd_bl_data *ktd = container_of(desc, struct ktd_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(ktd->pdev);
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
backlight_mode = BACKLIGHT_RESUME;
#if CABC_FEATURE_ON
if (cabc_status)
backlight_cabc_on();
else
backlight_cabc_off();
#endif
BLDBG("[%02d:%02d:%02d.%03lu][BACKLIGHT] late resume\n",
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
if(0 != bl->props.brightness)
backlight_update_status(bl);
}
static void aat1401_backlight_earlysuspend(struct early_suspend *desc)
{
struct aat1401_bl_data *aat1401 = container_of(desc, struct aat1401_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(aat1401->pdev);
backlight_mode=BACKLIGHT_SUSPEND;
BLDBG("[BACKLIGHT] aat1401_backlight_earlysuspend\n");
}
static int ktd259b_backlight_probe(struct platform_device *pdev)
{
struct platform_ktd259b_backlight_data *data = pdev->dev.platform_data;
struct backlight_device *bl;
struct ktd259b_bl_data *ktd259b;
struct backlight_properties props;
int ret;
BLDBG("[BACKLIGHT] ktd259b_backlight_probe\n");
if (!data) {
dev_err(&pdev->dev, "failed to find platform data\n");
return -EINVAL;
}
ktd259b = kzalloc(sizeof(*ktd259b), GFP_KERNEL);
if (!ktd259b) {
dev_err(&pdev->dev, "no memory for state\n");
ret = -ENOMEM;
goto err_alloc;
}
ktd259b->ctrl_pin = data->ctrl_pin;
memset(&props, 0, sizeof(struct backlight_properties));
props.max_brightness = data->max_brightness;
props.type = BACKLIGHT_PLATFORM;
bl = backlight_device_register(pdev->name, &pdev->dev,
ktd259b, &ktd259b_backlight_ops, &props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
ret = PTR_ERR(bl);
goto err_bl;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
ktd259b->pdev = pdev;
ktd259b->early_suspend_desc.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
ktd259b->early_suspend_desc.suspend = ktd259b_backlight_earlysuspend;
ktd259b->early_suspend_desc.resume = ktd259b_backlight_earlyresume;
register_early_suspend(&ktd259b->early_suspend_desc);
#endif
bl->props.max_brightness = data->max_brightness;
bl->props.brightness = data->dft_brightness;
platform_set_drvdata(pdev, bl);
ktd259b_backlight_update_status(bl);
return 0;
err_bl:
kfree(ktd259b);
err_alloc:
return ret;
}
static int ktd259b_backlight_resume(struct platform_device *pdev)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
BLDBG("[BACKLIGHT] ktd259b_backlight_resume\n");
backlight_update_status(bl);
return 0;
}
/* input: intensity in percentage 0% - 100% */
static int tps61158_backlight_update_status(struct backlight_device *bd)
{
int user_intensity = bd->props.brightness;
int tune_level = 0;
int i;
BLDBG("[BACKLIGHT] tps61158_backlight_update_status ==> user_intensity : %d\n", user_intensity);
if (bd->props.power != FB_BLANK_UNBLANK)
user_intensity = 0;
if (bd->props.fb_blank != FB_BLANK_UNBLANK)
user_intensity = 0;
if (bd->props.state & BL_CORE_SUSPENDED)
user_intensity = 0;
if(backlight_mode != BACKLIGHT_RESUME)
{
// BLDBG("[BACKLIGHT] Returned with invalid backlight mode %d\n", backlight_mode);
return 0;
}
if(user_intensity > 0) {
if(user_intensity < MIN_BRIGHTNESS_VALUE) {
tune_level = DIMMING_VALUE; //DIMMING
} else if (user_intensity == MAX_BRIGHTNESS_VALUE) {
tune_level = brt_table[MAX_BRT_STAGE-1].tune_level;
} else {
for(i = 0; i < MAX_BRT_STAGE; i++) {
if(user_intensity <= brt_table[i].level ) {
tune_level = brt_table[i].tune_level;
break;
}
}
}
}
BLDBG("[BACKLIGHT] tps61158_backlight_update_status ==> tune_level : %d\n", tune_level);
backlight_control(tune_level);
return 0;
}
static int ktd259b_backlight_suspend(struct platform_device *pdev,
pm_message_t state)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
struct ktd259b_bl_data *ktd259b = dev_get_drvdata(&bl->dev);
BLDBG("[BACKLIGHT] ktd259b_backlight_suspend\n");
return 0;
}
static void aat1401_backlight_earlyresume(struct early_suspend *desc)
{
struct aat1401_bl_data *aat1401 = container_of(desc, struct aat1401_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(aat1401->pdev);
backlight_mode=BACKLIGHT_RESUME;
BLDBG("[BACKLIGHT] aat1401_backlight_earlyresume\n");
backlight_update_status(bl);
}
static int ktd_backlight_remove(struct platform_device *pdev)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
struct ktd_bl_data *ktd = dev_get_drvdata(&bl->dev);
backlight_device_unregister(bl);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&ktd->early_suspend_desc);
#endif
BLDBG("[BACKLIGHT] ktd_backlight_remove\n");
return 0;
}
static ssize_t brightness_pulse_setting(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct lcd_info *lcd = dev_get_drvdata(dev);
int rc;
BLDBG("[BACKLIGHT] brightness_pulse_setting\n");
rc = strict_strtoul(buf, (unsigned int)0,
(unsigned long *)&pulse_value);
if (rc < 0)
return rc;
else {
if (pulse_value <= 32 && pulse_value >= 1) {
BLDBG("brightness_pulse_setting, pulse value=%d\n",
pulse_value);
lcd_backlight_control(pulse_value);
} else
BLDBG("out of range !!\n");
}
return size;
}
static void ktd_backlight_earlysuspend(struct early_suspend *desc)
{
struct timespec ts;
struct rtc_time tm;
backlight_mode = BACKLIGHT_SUSPEND;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
if(1 == gpio_get_value(backlight_pin)){
gpio_set_value(backlight_pin, 0);
mdelay(3);
}
BLDBG("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlysuspend\n",
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
/* input: intensity in percentage 0% - 100% */
static int ktd259b_backlight_update_status(struct backlight_device *bd)
{
int user_intensity = bd->props.brightness;
int tune_level = 0;
int pulse;
int i;
BLDBG("[BACKLIGHT] ktd259b_backlight_update_status ==> user_intensity : %d\n", user_intensity);
g_bl.props.brightness = user_intensity;
current_intensity = user_intensity;
if(backlight_mode==BACKLIGHT_RESUME){
#ifdef PWM_BRIGHTNESS
return vc_display_bus_write(0,0x51,&user_intensity,1);
#endif
if(user_intensity > 0) {
if(user_intensity < MIN_BRIGHTNESS_VALUE) {
tune_level = DIMMING_VALUE; /* DIMMING */
}else if (user_intensity == MAX_BRIGHTNESS_VALUE) {
if(cabc_status){
tune_level = brt_table_ktd_cabc[MAX_BRT_STAGE_KTD_CABC-1].tune_level;
}else{
tune_level = brt_table_ktd[MAX_BRT_STAGE_KTD-1].tune_level;
}
}else{
if(cabc_status){
BLDBG("[BACKLIGHT] cabc ON!\n");
for(i = 0; i < MAX_BRT_STAGE_KTD_CABC; i++) {
if(user_intensity <= brt_table_ktd_cabc[i].level ) {
tune_level = brt_table_ktd_cabc[i].tune_level;
break;
}
}
}else{
BLDBG("[BACKLIGHT] cabc OFF!\n");
for(i = 0; i < MAX_BRT_STAGE_KTD; i++) {
if(user_intensity <= brt_table_ktd[i].level ) {
tune_level = brt_table_ktd[i].tune_level;
break;
}
}
}
}
}
if (real_level==tune_level){
return 0;
}else{
if(tune_level<=0){
gpio_set_value(backlight_pin,0);
mdelay(3);
}else{
if( real_level<=tune_level){
pulse = tune_level - real_level;
}else{
pulse = 32 - (real_level - tune_level);
}
if (pulse==0){
return 0;
}
BLDBG("[BACKLIGHT] ktd259b_backlight_update_status ==> tune_level : %d & pulse = %d\n", tune_level, pulse);
lcd_backlight_control(pulse);
}
real_level = tune_level;
return 0;
}
}
return 0;
}
static int cat4253_backlight_update_status(struct backlight_device *bd)
{
//struct cat4253_bl_data *cat4253= dev_get_drvdata(&bd->dev);
int user_intensity = bd->props.brightness;
int pulse = 0;
int i;
//printk("[BACKLIGHT] cat4253_backlight_update_status ==> user_intensity : %d\n", user_intensity);
BLDBG("[BACKLIGHT] cat4253_backlight_update_status ==> user_intensity : %d\n", user_intensity);
if(backlight_mode==BACKLIGHT_RESUME)
{
if(gLcdfbEarlySuspendStopDraw==0)
{
if(user_intensity > 0)
{
if(user_intensity < MIN_BRIGHTNESS_VALUE)
{
CurrDimmingPulse = DIMMING_VALUE; //DIMMING
}
else if (user_intensity == MAX_BRIGHTNESS_VALUE)
{
CurrDimmingPulse = brt_table_ktd[MAX_BRT_STAGE_KTD-1].tune_level;
}
else
{
for(i = 0; i < MAX_BRT_STAGE_KTD; i++)
{
if(user_intensity <= brt_table_ktd[i].level )
{
CurrDimmingPulse = brt_table_ktd[i].tune_level;
break;
}
}
}
}
else
{
BLDBG("[BACKLIGHT] cat4253_backlight_update_status ==> OFF\n");
CurrDimmingPulse = 0;
gpio_set_value(backlight_pin,0);
mdelay(10);
PrevDimmingPulse = CurrDimmingPulse;
return 0;
}
//printk("[BACKLIGHT] cat4253_backlight_update_status ==> Prev = %d, Curr = %d\n", PrevDimmingPulse, CurrDimmingPulse);
BLDBG("[BACKLIGHT] cat4253_backlight_update_status ==> Prev = %d, Curr = %d\n", PrevDimmingPulse, CurrDimmingPulse);
if (PrevDimmingPulse == CurrDimmingPulse)
{
//printk("[BACKLIGHT] cat4253_backlight_update_status ==> Same brightness\n");
PrevDimmingPulse = CurrDimmingPulse;
return 0;
}
else
{
if(PrevDimmingPulse == 0)
{
mdelay(200);
//When backlight OFF->ON, only first pulse should have 2ms HIGH level.
gpio_set_value(backlight_pin,1);
mdelay(2);//for HW 0.2, FAN5345
//udelay(2);//for HW 0.3, KTD253B
}
if(PrevDimmingPulse < CurrDimmingPulse)
{
pulse = (32 + PrevDimmingPulse) - CurrDimmingPulse;
}
else if(PrevDimmingPulse > CurrDimmingPulse)
{
pulse = PrevDimmingPulse - CurrDimmingPulse;
}
lcd_backlight_control(pulse);
//printk("[BACKLIGHT] cat4253_backlight_update_status ==> Prev = %d, Curr = %d, pulse = %d\n", PrevDimmingPulse, CurrDimmingPulse, pulse);
PrevDimmingPulse = CurrDimmingPulse;
return 0;
}
}
}
PrevDimmingPulse = CurrDimmingPulse;
return 0;
}
static int ktd259b_backlight_get_brightness(struct backlight_device *bl)
{
BLDBG("[BACKLIGHT] ktd259b_backlight_get_brightness\n");
return current_intensity;
}
/* input: intensity in percentage 0% - 100% */
static int ktd259b_backlight_update_status(struct backlight_device *bd)
{
int user_intensity = bd->props.brightness;
int tune_level = 0;
int pulse;
int i;
BLDBG("[BACKLIGHT] ktd259b_backlight_update_status ==> user_intensity : %d\n", user_intensity);
if(backlight_mode==BACKLIGHT_RESUME){
if(user_intensity > 0) {
if(user_intensity < MIN_BRIGHTNESS_VALUE) {
tune_level = DIMMING_VALUE; //DIMMING
} else if (user_intensity == MAX_BRIGHTNESS_VALUE) {
tune_level = brt_table_ktd[MAX_BRT_STAGE_KTD-1].tune_level;
} else {
for(i = 0; i < MAX_BRT_STAGE_KTD; i++) {
if(user_intensity <= brt_table_ktd[i].level ) {
tune_level = brt_table_ktd[i].tune_level;
break;
}
}
}
}
BLDBG("[BACKLIGHT] ktd259b_backlight_update_status ==> tune_level : %d\n", tune_level);
if (real_level==tune_level)
{
return 0;
}
else
{
/* if(real_level == 0)
{
mdelay(200);
}
*/
if(tune_level<=0)
{
gpio_set_value(backlight_pin,0);
mdelay(3);
}
else
{
if( real_level<=tune_level)
{
pulse = tune_level - real_level;
}
else
{
pulse = 32 - (real_level - tune_level);
}
//pulse = MAX_BRIGHTNESS_IN_BLU -tune_level;
if (pulse==0)
{
return 0;
}
lcd_backlight_control(pulse);
}
real_level = tune_level;
return 0;
}
}
return 0;
}
void backlight_update_CABC()
{
BLDBG("[BACKLIGHT] backlight_update_CABC\n");
ktd_backlight_update_status(&g_bl);
}
/* input: intensity in percentage 0% - 100% */
static int aat1401_backlight_update_status(struct backlight_device *bd)
{
struct aat1401_bl_data *aat1401= dev_get_drvdata(&bd->dev);
int user_intensity = bd->props.brightness;
int tune_level = 0;
int pulse;
int i;
BLDBG("[BACKLIGHT] aat1401_backlight_update_status ==> user_intensity : %d\n", user_intensity);
if((check_initial==1)&&(backlight_mode==BACKLIGHT_RESUME))
{
if(gLcdfbEarlySuspendStopDraw==0)
{
if(user_intensity > 0) {
if(user_intensity < MIN_BRIGHTNESS_VALUE) {
tune_level = DIMMING_VALUE; //DIMMING
} else if (user_intensity == MAX_BRIGHTNESS_VALUE) {
tune_level = brt_table_ktd[MAX_BRT_STAGE_KTD-1].tune_level;
} else {
for(i = 0; i < MAX_BRT_STAGE_KTD; i++) {
if(user_intensity <= brt_table_ktd[i].level ) {
tune_level = brt_table_ktd[i].tune_level;
break;
}
}
}
}
//printk("[BACKLIGHT] aat1401_backlight_update_status ==> tune_level : %d\n", tune_level);
BLDBG("[BACKLIGHT] aat1401_backlight_update_status ==> tune_level : %d\n", tune_level);
if (real_level==tune_level)
{
return 0;
}
else
{
if(real_level == 0)
{
mdelay(400);
}
if(tune_level<=0)
{
gpio_set_value(backlight_pin,0);
mdelay(3);
}
else
{
pulse = MAX_BRIGHTNESS_IN_BLU -tune_level;
if (pulse==0)
{
return 0;
}
gpio_set_value(backlight_pin,0);
udelay(80);
lcd_backlight_control(pulse);
}
real_level = tune_level;
return 0;
}
}
}
}
static int ktd_backlight_probe(struct platform_device *pdev)
{
struct platform_ktd2801_backlight_data *data = NULL;
struct backlight_device *bl;
struct ktd_bl_data *ktd;
struct backlight_properties props;
int ret=0;
BLDBG("[BACKLIGHT] backlight driver probe\n");
if (pdev->dev.of_node) {
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
if (!data) {
dev_err(&pdev->dev, "no memory for state\n");
return -ENOMEM;
}
if (get_platform_data(pdev, data)) {
dev_err(&pdev->dev, "get_platform_data error\n");
return -EINVAL;
}
} else {
dev_info(&pdev->dev, "No Device Tree\n");
data = pdev->dev.platform_data;
}
ktd = devm_kzalloc(&pdev->dev, sizeof(*ktd), GFP_KERNEL);
if (!ktd) {
dev_err(&pdev->dev, "no memory for state\n");
return -ENOMEM;
}
//backlight_pin = data->ctrl_pin;
backlight_pin = 24;
ret = gpio_request(backlight_pin, "BL_CTRL");
if(ret)
BLDBG("BACKLIGHT GPIO REQUEST FAIL!\n");
gpio_direction_output(backlight_pin, 1);
BLDBG("[BACKLIGHT] backlight_pin == %d\n", backlight_pin);
memset(&props, 0, sizeof(struct backlight_properties));
props.max_brightness = data->max_brightness;
props.type = BACKLIGHT_PLATFORM;
bl = backlight_device_register("panel", &pdev->dev,
ktd, &ktd_backlight_ops, &props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
return PTR_ERR(bl);
}
#if CABC_FEATURE_ON
lcd_device_register("panel", &pdev->dev, NULL, NULL);
ret = device_create_file(&bl->dev, &dev_attr_auto_brightness);
if (ret < 0)
dev_err(&pdev->dev, "failed to add sysfs entries\n");
#endif
#if LCD_REGISTER
lcd_device_register("panel", &pdev->dev, NULL, NULL);
ret = device_create_file(&bl->dev, &dev_attr_manual_pulseset);
if (ret < 0)
dev_err(&pdev->dev, "failed to add sysfs entries\n");
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
ktd->pdev = pdev;
ktd->early_suspend_desc.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
ktd->early_suspend_desc.suspend = ktd_backlight_earlysuspend;
ktd->early_suspend_desc.resume = ktd_backlight_lateresume;
register_early_suspend(&ktd->early_suspend_desc);
#endif
bl->props.max_brightness = data->max_brightness;
bl->props.brightness = data->dft_brightness;
platform_set_drvdata(pdev, bl);
return 0;
}
