コード例 #1
0
ファイル: ktd_bl.c プロジェクト: Neves4/DatKernel
static void ktd259b_backlight_earlyresume(struct early_suspend *desc)
{
    struct ktd259b_bl_data *ktd259b = container_of(desc, struct ktd259b_bl_data,
                                                                          early_suspend_desc);
    struct backlight_device *bl = platform_get_drvdata(ktd259b->pdev);
    struct timespec ts;
    struct rtc_time tm;
#ifdef PWM_BRIGHTNESS    
    int temp_brightness = 0;
#endif   
    
    gpio_set_value(backlight_pwm,1);
    
#ifdef PWM_BRIGHTNESS 
    vc_display_bus_write(0,0x51,&temp_brightness,1);    
    mdelay(100);   
    lcd_backlight_control(5);
#endif
    
    getnstimeofday(&ts);
    rtc_time_to_tm(ts.tv_sec, &tm);
    backlight_mode=BACKLIGHT_RESUME;

     if(cabc_status)
     {
        backlight_cabc_on();
     }
     else
     {
        backlight_cabc_off();
     }
    
    printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlyresume\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
    backlight_update_status(bl);
}
コード例 #2
0
static void aat1402iuq_BacklightCtrlbySingleWire(int tune_level)
{

	int pulse;

	if(tune_level <= 0) 
	{
        gpio_direction_output(backlight_pin,0);
        
	    mdelay(1);
        
        #if defined(__BACKLIGHT_DEBUG__)
        printk("[BACKLIGHT] Backlight Off \n");
        #endif

	}
	else 
	{
         lcd_backlight_control(tune_level); 
	}

	
    udelay(550); // over 60us
	
	
}
コード例 #3
0
/* 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;
}
コード例 #4
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;
}
コード例 #5
0
/* 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;
}
コード例 #6
0
/* 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;
    }
    }
}
}
コード例 #7
0
ファイル: cat4253_bl.c プロジェクト: vM00/xm01
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;
}
コード例 #8
0
ファイル: ktd_bl.c プロジェクト: Neves4/DatKernel
/* 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;
}