Changeset 122


Ignore:
Timestamp:
Apr 14, 2011, 4:12:09 PM (6 years ago)
Author:
beamrider
Message:

LCD pm and mutex fixes

Location:
kern_oII/drivers
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • kern_oII/drivers/sensor/optical/isl29023.c

    r87 r122  
    112112        } 
    113113         
    114         if (lcd_late_resume)  
    115                 backlight_level_ctrl(light_state[cur_state].brightness); 
     114        backlight_level_ctrl(light_state[cur_state].brightness); 
    116115 
    117116        if (int_op_mode) 
  • kern_oII/drivers/sensor/optical/isl29023.h

    r87 r122  
    172172int isl_i2c_write( u8 reg, int val ); 
    173173extern void backlight_level_ctrl(s32 value); 
    174 extern int lcd_late_resume; 
    175174static int isl_attach_adapter(struct i2c_adapter *adap); 
    176175#endif 
  • kern_oII/drivers/video/samsung/s3cfb.h

    r2 r122  
    525525extern int s3cfb_is_clock_on(void); 
    526526 
     527#ifdef CONFIG_S3C64XX_DOMAIN_GATING 
     528#define USE_LCD_DOMAIN_GATING 
     529#endif /* CONFIG_S3C64XX_DOMAIN_GATING */ 
     530 
     531#ifdef USE_LCD_DOMAIN_GATING 
     532extern void s3cfb_domain_gating_on(void); 
     533extern int s3cfb_domain_gating_wait(void); 
     534extern void s3cfb_domain_gating_off(void); 
     535#endif /* USE_LCD_DOMAIN_GATING */ 
     536 
    527537#ifdef CONFIG_HAS_EARLYSUSPEND 
    528538extern void s3cfb_early_suspend(struct early_suspend *h); 
  • kern_oII/drivers/video/samsung/s3cfb_ams320fs01.c

    r2 r122  
    872872#define ONOFF2_ELDO6    (0x01 << 7) 
    873873#define ONOFF2_ELDO7    (0x03 << 6) 
    874 static s32 old_level = 0; 
     874static s32 old_level = -1; 
    875875 
    876876typedef enum { 
  • kern_oII/drivers/video/samsung/s3cfb_ams369fg.c

    r85 r122  
    1717#include <linux/platform_device.h> 
    1818#include <linux/leds.h> 
     19#include <linux/workqueue.h> 
    1920 
    2021#include <linux/i2c/maximi2c.h> 
     
    100101 
    101102 
    102 extern void s3cfb_enable_clock_power(void); 
    103 extern int s3cfb_is_clock_on(void); 
    104 extern int lcd_late_resume; 
     103extern int lcd_pm_status; 
    105104//extern void s3c_bat_set_compensation_for_drv(int mode,int offset); *FIXME* 
    106105 
     
    112111EXPORT_SYMBOL(lcd_reset); 
    113112 
    114 s3cfb_stop_progress(void) 
    115 { 
    116 }; 
    117 s3cfb_display_logo(void) 
    118 { 
    119 }; 
    120 s3cfb_start_progress(void) 
    121 { 
    122 }; 
    123  
    124 int lcd_power = OFF; 
    125 EXPORT_SYMBOL(lcd_power); 
    126  
    127113void lcd_power_ctrl(s32 value); 
    128114EXPORT_SYMBOL(lcd_power_ctrl); 
    129115 
    130 int backlight_power = OFF; 
    131 EXPORT_SYMBOL(backlight_power); 
    132  
    133116void backlight_power_ctrl(s32 value); 
    134117EXPORT_SYMBOL(backlight_power_ctrl); 
    135118 
    136 int backlight_level = BACKLIGHT_LEVEL_DEFAULT; 
    137 EXPORT_SYMBOL(backlight_level); 
    138  
    139119void backlight_level_ctrl(s32 value); 
    140120EXPORT_SYMBOL(backlight_level_ctrl); 
    141121 
    142 static s32 old_level = 0; 
    143 int lcd_gamma_present = 0; 
    144  
    145 static s32 ams320fs01_backlight_brightness = AMS320FS01_DEFAULT_BACKLIGHT_BRIGHTNESS; 
     122s32 lcd_gamma_present = 0; 
     123s32 old_level = 0; 
     124static struct workqueue_struct *ams320fs01_workqueue = NULL; 
    146125static DEFINE_MUTEX(ams320fs01_backlight_lock); 
    147 static s32 ams320fs01_backlight_off; 
    148 static u8 ams320fs01_backlight_last_level = 33; 
    149  
    150  
    151126 
    152127 
     
    456431 
    457432 
    458 void lcd_gamma_change(int gamma_status) 
    459 { 
     433void _lcd_gamma_change(int gamma_status) 
     434{ 
     435        struct setting_table *table = NULL; 
     436        int i; 
     437 
    460438        if(old_level < 1) 
    461439                return; 
    462440                 
    463441        //printk("[S3C LCD] %s : level %d, gamma_status %d\n", __FUNCTION__, (old_level-1), gamma_status); 
    464         int i; 
    465  
    466         if(gamma_status == LCD_IDLE) 
     442 
     443        switch (gamma_status) 
    467444        { 
    468                 lcd_gamma_present = LCD_IDLE; 
    469                 for (i = 0; i < GAMMA_SETTINGS; i++) 
    470                         setting_table_write(&gamma_setting_table[(old_level - 1)][i]); 
    471         } 
    472         else if(gamma_status == LCD_VIDEO) 
    473         { 
    474                 lcd_gamma_present = LCD_VIDEO; 
    475                 for (i = 0; i < GAMMA_SETTINGS; i++) 
    476                         setting_table_write(&gamma_setting_table_video[(old_level - 1)][i]); 
    477         } 
    478         else if(gamma_status == LCD_CAMERA) 
    479         { 
    480                 lcd_gamma_present = LCD_CAMERA; 
    481                 for (i = 0; i < GAMMA_SETTINGS; i++) 
    482                         setting_table_write(&gamma_setting_table_cam[(old_level - 1)][i]); 
    483         } 
    484         else 
     445        case LCD_IDLE: 
     446                table = gamma_setting_table[(old_level - 1)]; 
     447                break; 
     448        case LCD_VIDEO: 
     449                table = gamma_setting_table_video[(old_level - 1)]; 
     450                break; 
     451        case LCD_CAMERA: 
     452                table = gamma_setting_table_cam[(old_level - 1)]; 
     453                break; 
     454        default: 
    485455                return; 
    486 } 
    487  
     456        } 
     457 
     458        lcd_gamma_present = gamma_status; 
     459 
     460        for (i = 0; i < GAMMA_SETTINGS; i++) 
     461                setting_table_write(&table[i]); 
     462 
     463} 
     464 
     465void lcd_gamma_change(int gamma_status) 
     466{ 
     467        mutex_lock(&ams320fs01_backlight_lock); 
     468        lcd_gamma_change(gamma_status); 
     469        mutex_unlock(&ams320fs01_backlight_lock); 
     470} 
    488471EXPORT_SYMBOL(lcd_gamma_change); 
    489472 
    490 void lcd_power_ctrl(s32 value) 
     473static void _lcd_power_ctrl(s32 value) 
    491474{ 
    492475        //printk("lcd_power_ctrl value=%x \n", value); 
     476        static int lcd_power = OFF; 
    493477        s32 i;   
    494478        u8 data; 
    495         u32 timeout = 100; 
     479 
     480        value = (value)?ON:OFF; 
     481 
     482        if (lcd_power == value) 
     483                return; 
     484 
    496485        if (value) { 
    497                 while (timeout-- > 0) { 
    498                         if (lcd_late_resume == 1) 
    499                                 break; 
    500                         msleep(50); 
    501                 }  
     486                printk("Lcd power on sequence start\n"); 
     487 
     488                /* Power On Sequence */ 
     489                //s3c_bat_set_compensation_for_drv(1,OFFSET_LCD_ON); *FIXME* 
     490 
     491                /* Reset Asseert */ 
     492                gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_LOW); 
     493                msleep(20); 
     494 
     495                /* Power Enable */ 
     496                if(pmic_read(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
     497                        printk(KERN_ERR "LCD POWER CONTROL can't read the status from PMIC\n"); 
     498                } 
     499 
     500                data |= (ONOFF2_ELDO6) | (ONOFF2_ELDO7); 
     501 
     502                if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
     503                        printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
     504                } 
     505 
     506                gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_HIGH); 
     507 
     508                msleep(20); 
     509 
     510                for (i = 0; i < POWER_ON_SETTINGS; i++) 
     511                        setting_table_write(&power_on_setting_table[i]); 
     512                spi_write2(0xE8); // 3rd value 
     513 
     514 
     515 
     516                spi_write(0x3944); //set gamma have to check! 
     517                _lcd_gamma_change(lcd_gamma_present); 
     518 
     519                for (i = 0; i < DISPLAY_ON_SETTINGS; i++) 
     520                        setting_table_write(&display_on_setting_table[i]); 
     521                printk("Lcd power on sequence end\n"); 
     522 
     523        } else { 
     524                printk("Lcd power off sequence start\n"); 
     525                /* Power Off Sequence */ 
     526 
     527                //s3c_bat_set_compensation_for_drv(0,OFFSET_LCD_ON); *FIXME* 
     528 
     529                for (i = 0; i < DISPLAY_OFF_SETTINGS; i++) 
     530                        setting_table_write(&display_off_setting_table[i]); 
    502531                 
    503                 if (timeout == -1) { 
    504                         printk(KERN_ERR "lcd power control time out\n"); 
     532                /* Reset Assert */ 
     533                gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_LOW); 
     534 
     535                /* Power Disable */ 
     536                if(pmic_read(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
     537                        printk(KERN_ERR "LCD POWER CONTROL can't read the status from PMIC\n"); 
    505538                        //return -1; 
    506539                } 
    507  
    508                 //printk("Lcd power on sequence start\n"); 
    509  
    510                 /* Power On Sequence */ 
    511                         //s3c_bat_set_compensation_for_drv(1,OFFSET_LCD_ON); *FIXME* 
    512  
    513                         /* Reset Asseert */ 
    514                         gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_LOW); 
    515                         //gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_HIGH); 
    516                         msleep(20); 
    517          
    518                         /* Power Enable */ 
    519                         if(pmic_read(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    520                                 printk(KERN_ERR "LCD POWER CONTROL can't read the status from PMIC\n"); 
    521                                 //return -1; 
    522                         } 
    523                         data |= (ONOFF2_ELDO6); 
    524                          
    525                         if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    526                                 printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
     540                data &= ~(ONOFF2_ELDO6 | ONOFF2_ELDO7); 
     541 
     542                if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
     543                        printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
    527544                        //return -1; 
    528                         } 
    529                         msleep(1); 
    530  
    531                         data |= (ONOFF2_ELDO7); 
    532                          
    533                         if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    534                                 printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
    535                         //return -1; 
    536                         } 
    537  
    538  
    539                         gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_HIGH); 
    540  
    541                         msleep(20);              
    542          
    543                         for (i = 0; i < POWER_ON_SETTINGS; i++) 
    544                                 setting_table_write(&power_on_setting_table[i]); 
    545                         spi_write2(0xE8); // 3rd value 
    546  
    547          
    548  
    549                         switch(lcd_gamma_present) 
    550                         { 
    551                                 printk("[S3C LCD] %s : level dimming, lcd_gamma_present %d\n", __FUNCTION__, lcd_gamma_present); 
    552                                 spi_write(0x3944); //set gamma have to check! 
    553  
    554                                 case LCD_IDLE: 
    555                                         for (i = 0; i < GAMMA_SETTINGS; i++) 
    556                                                 setting_table_write(&gamma_setting_table[1][i]); 
    557                                         break; 
    558                                 case LCD_VIDEO: 
    559                                         for (i = 0; i < GAMMA_SETTINGS; i++) 
    560                                                 setting_table_write(&gamma_setting_table_video[1][i]); 
    561                                         break; 
    562                                 case LCD_CAMERA: 
    563                                         for (i = 0; i < GAMMA_SETTINGS; i++) 
    564                                                 setting_table_write(&gamma_setting_table_cam[1][i]); 
    565                                         break; 
    566                                 default: 
    567                                         break; 
    568                         } 
    569                          
    570                         for (i = 0; i < DISPLAY_ON_SETTINGS; i++) 
    571                                 setting_table_write(&display_on_setting_table[i]);       
    572                         //printk("Lcd power on sequence end\n"); 
    573  
    574 } 
    575                 else { 
    576                         //printk("Lcd power off sequence start\n"); 
    577                         /* Power Off Sequence */ 
    578  
    579                         //s3c_bat_set_compensation_for_drv(0,OFFSET_LCD_ON); *FIXME* 
    580  
    581                         for (i = 0; i < DISPLAY_OFF_SETTINGS; i++) 
    582                                 setting_table_write(&display_off_setting_table[i]);      
    583                          
    584                         /* Reset Assert */ 
    585                         gpio_set_value(GPIO_LCD_RST_N, GPIO_LEVEL_LOW); 
    586  
    587                         /* Power Disable */ 
    588                         if(pmic_read(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    589                                 printk(KERN_ERR "LCD POWER CONTROL can't read the status from PMIC\n"); 
    590                                 //return -1; 
    591                         } 
    592                         data &= ~(ONOFF2_ELDO7); 
    593                  
    594                         if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    595                                 printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
    596                                 //return -1; 
    597                         } 
    598                         msleep(1); 
    599                         data &= ~(ONOFF2_ELDO6); 
    600                  
    601                         if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    602                                 printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
    603                                 //return -1; 
    604                         } 
    605                         msleep(1); 
    606                         printk("Lcd power off sequence end\n"); 
    607545                } 
    608          
    609                 lcd_power = value; 
    610         } 
    611  
    612  
    613 void backlight_ctrl(s32 value) 
    614 { 
    615         //printk("backlight_ctrl is called VALUE = %x \n", value); 
     546 
     547                msleep(1); 
     548                printk("Lcd power off sequence end\n"); 
     549        } 
     550 
     551        lcd_power = value; 
     552} 
     553 
     554static void _backlight_ctrl(s32 value) 
     555{ 
     556 
    616557        s32 i, level; 
    617         u8 data; 
    618         int param_lcd_level = value; 
     558 
     559        printk("backlight_ctrl is called VALUE = %x \n", value); 
    619560 
    620561        value &= BACKLIGHT_LEVEL_VALUE; 
     
    630571 
    631572        if (level) {     
    632         //printk(" backlight_ctrl level:%x, old_level:%x &value=%x\n", level, old_level, value);                 
     573                _lcd_power_ctrl(ON); 
     574                printk(" backlight_ctrl level:%x, old_level:%x &value=%x\n", level, old_level, value); 
    633575                if (level != old_level) { 
     576 
    634577                        old_level = level; 
    635  
    636                         if (lcd_power == OFF) 
    637                         { 
    638                                 //printk("LCD power == OFF \n"); 
    639                                 if(!s3cfb_is_clock_on()) 
    640                                 { 
    641                                         //printk("s3cfb_enable_clock_power \n"); 
    642                                         s3cfb_enable_clock_power(); 
    643                                 } 
    644                                 //printk("lcd_power_ctrl(ON) \n"); 
    645                                 lcd_power_ctrl(ON); 
    646                         } 
    647578 
    648579                        //printk("LCD Backlight level setting value ==> %d  , level ==> %d \n",value,level); 
     
    673604                //printk("lcd_power_ctrl(OFF) \n"); 
    674605                old_level = level; 
    675                 lcd_power_ctrl(OFF);                     
    676         } 
    677 } 
    678  
    679 void backlight_level_ctrl(s32 value) 
    680 { 
    681         //printk("backlight level ctrl called, Previous backlight_VALUE =%x \n, NEW VALUE = %x", backlight_level, value); 
    682         if ((value < BACKLIGHT_LEVEL_MIN) ||    /* Invalid Value */ 
    683                 (value > BACKLIGHT_LEVEL_MAX) || 
    684                 (value == backlight_level))     /* Same Value */ 
    685                 return; 
    686  
    687         //printk("%s %d\n", __FUNCTION__, __LINE__); 
    688  
    689         if (lcd_late_resume == 0) { 
    690                 printk(KERN_ERR "backlight control is not allowed after early suspend\n"); 
    691                 return; 
    692         } 
    693  
    694  
    695         //if (backlight_power) 
    696         backlight_ctrl(value);   
    697          
    698         backlight_level = value;         
    699 } 
    700  
    701 void backlight_power_ctrl(s32 value) 
    702 { 
    703         //printk("backlight_power_ctrl VALUE: %x \n", value); 
    704         if ((value < OFF) ||    /* Invalid Value */ 
    705                 (value > ON)) 
    706                 return; 
    707  
    708         backlight_ctrl((value ? backlight_level : OFF));         
    709          
    710         backlight_power = (value ? ON : OFF); 
    711 } 
    712  
    713 static void ams320fs01_set_backlight_level(u8 level) 
    714 { 
    715         //printk("ams320fs01_set_backlight_level VALUE = %x BACLIGHT_LEVEL= %x \n", level, backlight_level); 
    716         if (backlight_level == level) 
    717                 return; 
    718  
    719         backlight_ctrl(level); 
    720  
    721         backlight_level = level; 
    722 } 
    723  
    724 static void ams320fs01_brightness_set(struct led_classdev *led_cdev, enum led_brightness value) 
    725 { 
    726         //printk("ams320fs01_brightness_set \n"); 
    727         mutex_lock(&ams320fs01_backlight_lock); 
    728         ams320fs01_backlight_brightness = value; 
    729         ams320fs01_set_backlight_level(ams320fs01_backlight_brightness); 
    730         mutex_unlock(&ams320fs01_backlight_lock); 
    731 } 
     606                _lcd_power_ctrl(OFF); 
     607        } 
     608} 
     609 
     610static void ams320fs01_brightness_set(struct led_classdev *led_cdev, enum led_brightness value); 
    732611 
    733612static struct led_classdev ams320fs01_backlight_led  = { 
     
    737616}; 
    738617 
     618 
     619static void backlight_ctrl_f(struct work_struct *work) 
     620{ 
     621        mutex_lock(&ams320fs01_backlight_lock); 
     622        _backlight_ctrl(ams320fs01_backlight_led.brightness); 
     623        mutex_unlock(&ams320fs01_backlight_lock); 
     624} 
     625 
     626DECLARE_WORK(ams320fs01_brightness_work, backlight_ctrl_f); 
     627 
     628static int last_on_brightness = AMS320FS01_DEFAULT_BACKLIGHT_BRIGHTNESS; 
     629 
     630void lcd_power_ctrl(s32 value) 
     631{ 
     632        mutex_lock(&ams320fs01_backlight_lock); 
     633        _lcd_power_ctrl(value?ON:OFF); 
     634        mutex_unlock(&ams320fs01_backlight_lock); 
     635} 
     636 
     637void backlight_level_ctrl(s32 value) 
     638{ 
     639 
     640        //printk("backlight level ctrl called, Previous backlight_VALUE =%x \n, NEW VALUE = %x", backlight_level, value); 
     641        if ((value < BACKLIGHT_LEVEL_MIN) ||    /* Invalid Value */ 
     642                (value > BACKLIGHT_LEVEL_MAX)) 
     643                return; 
     644 
     645        mutex_lock(&ams320fs01_backlight_lock); 
     646        if (value != OFF) 
     647                last_on_brightness = value; 
     648 
     649        ams320fs01_backlight_led.brightness = value; 
     650 
     651        if (lcd_pm_status == ON) 
     652        { 
     653                _backlight_ctrl(ams320fs01_backlight_led.brightness); 
     654        } 
     655        mutex_unlock(&ams320fs01_backlight_lock); 
     656} 
     657 
     658void backlight_power_ctrl(s32 value) 
     659{ 
     660        //printk("backlight_power_ctrl VALUE: %x \n", value); 
     661        if ((value < OFF) ||    /* Invalid Value */ 
     662                (value > ON)) 
     663                return; 
     664 
     665        backlight_level_ctrl(value ? last_on_brightness : OFF); 
     666} 
     667 
     668static void ams320fs01_brightness_set(struct led_classdev *led_cdev, enum led_brightness value) 
     669{ 
     670        if ((value < BACKLIGHT_LEVEL_MIN) ||    /* Invalid Value */ 
     671                (value > BACKLIGHT_LEVEL_MAX)) 
     672                return; 
     673 
     674        mutex_lock(&ams320fs01_backlight_lock); 
     675        if (value != OFF) 
     676                last_on_brightness = value; 
     677 
     678        ams320fs01_backlight_led.brightness = value; 
     679        mutex_unlock(&ams320fs01_backlight_lock); 
     680 
     681        if (lcd_pm_status == ON) 
     682                queue_work(ams320fs01_workqueue, &ams320fs01_brightness_work); 
     683 
     684} 
     685 
    739686static int ams320fs01_open (struct inode *inode, struct file *filp) 
    740687{ 
     
    755702{ 
    756703        int ret = 0; 
    757         void __user *argp = (void __user *)arg;    
     704//      void __user *argp = (void __user *)arg; 
    758705 
    759706        if( _IOC_TYPE(ioctl_cmd) != AMS320FS01_IOC_MAGIC ) 
     
    843790                .owner          = THIS_MODULE, 
    844791        }, 
     792 
    845793}; 
    846794 
    847795static int __init ams320fs01_backlight_init(void) 
    848796{ 
     797        ams320fs01_workqueue = create_singlethread_workqueue("ams320fs01-backlight"); 
    849798        return platform_driver_register(&ams320fs01_backlight_driver); 
    850799} 
     
    852801static void __exit ams320fs01_backlight_exit(void) 
    853802{ 
     803        if (ams320fs01_workqueue) 
     804                destroy_workqueue(ams320fs01_workqueue); 
     805 
    854806        platform_driver_unregister(&ams320fs01_backlight_driver);  
    855807} 
     
    859811void s3cfb_init_hw(void) 
    860812{ 
    861         s3cfb_set_fimd_info(); 
     813#ifdef USE_LCD_DOMAIN_GATING 
     814        s3cfb_domain_gating_on(); 
     815        if (s3cfb_domain_gating_wait() < 0) 
     816        { 
     817        printk(KERN_ERR "[%s] Domain F is not ready\n", __func__); 
     818        return; 
     819        } 
     820#endif /* USE_LCD_DOMAIN_GATING */ 
     821 
     822    s3cfb_set_fimd_info(); 
    862823        s3cfb_set_gpio(); 
    863824        lcd_gpio_init(); 
    864 } 
    865  
    866  
    867  
     825 
     826} 
     827 
     828void s3cfb_display_logo(int win_num) 
     829{ 
     830} 
     831 
     832 
     833void s3cfb_start_progress(void) 
     834{ 
     835} 
     836 
     837void s3cfb_stop_progress(void) 
     838{ 
     839} 
     840 
     841 
  • kern_oII/drivers/video/samsung/s3cfb_fimd4x.c

    r78 r122  
    4646 
    4747 
    48 #ifdef CONFIG_S3C64XX_DOMAIN_GATING 
    49 #define USE_LCD_DOMAIN_GATING 
    50 #endif /* CONFIG_S3C64XX_DOMAIN_GATING */ 
    51  
    5248#if defined(CONFIG_PM) 
    5349#include <plat/pm.h> 
    5450#include <plat/power-clock-domain.h> 
    55 extern int backlight_power; 
    5651#endif 
    5752 
     
    19101905}; 
    19111906 
     1907int lcd_pm_status = ON; 
     1908static int lcd_clock_status = ON; 
     1909 
     1910#ifdef USE_LCD_DOMAIN_GATING 
     1911 
     1912void s3cfb_domain_gating_on() 
     1913{ 
     1914        s3c_set_normal_cfg(S3C64XX_DOMAIN_F, S3C64XX_ACTIVE_MODE, S3C64XX_LCD); 
     1915} 
     1916 
     1917int s3cfb_domain_gating_wait() 
     1918{ 
     1919        return s3c_wait_blk_pwr_ready(S3C64XX_BLK_F); 
     1920} 
     1921 
     1922void s3cfb_domain_gating_off() 
     1923{ 
     1924        s3c_set_normal_cfg(S3C64XX_DOMAIN_F, S3C64XX_LP_MODE, S3C64XX_LCD); 
     1925} 
     1926 
     1927#endif /* USE_LCD_DOMAIN_GATING */ 
     1928 
     1929static int s3cfb_suspend_sub(s3c_fb_info_t *fbi) 
     1930{ 
     1931 
     1932        printk("#%s lcd_pm_status=%d\n", __func__, lcd_pm_status); 
     1933        if (lcd_pm_status == OFF) 
     1934        { 
     1935        printk(KERN_WARNING "[%s] LCD is already in powersave mode\n", __func__); 
     1936                return -1; 
     1937        } 
     1938 
     1939        s3c6410_pm_do_save(s3c_lcd_save, ARRAY_SIZE(s3c_lcd_save)); 
     1940 
     1941    s3cfb_set_backlight_power(OFF); 
     1942 
     1943    /* for Idle Current GPIO Setting */ 
     1944    __raw_writel(0x55555555, S3C64XX_GPICON); 
     1945    __raw_writel(0x0, S3C64XX_GPIDAT); 
     1946    __raw_writel(0x55555555, S3C64XX_GPIPUD); 
     1947    __raw_writel(0x55555555, S3C64XX_GPJCON); 
     1948    __raw_writel(0x0, S3C64XX_GPJDAT); 
     1949    __raw_writel(0x55555555, S3C64XX_GPJPUD); 
     1950 
     1951    /* sleep before disabling the clock, we need to ensure 
     1952         * the LCD DMA engine is not going to get back on the bus 
     1953     * before the clock goes off again (bjd) */ 
     1954 
     1955    mdelay(1); //already breaking up 
     1956 
     1957    clk_disable(fbi->clk); 
     1958    lcd_clock_status = OFF; 
     1959 
     1960 
     1961        lcd_pm_status = OFF; 
     1962 
     1963 
     1964    return 0; 
     1965} 
     1966 
     1967static int s3cfb_resume_sub(s3c_fb_info_t *fbi) 
     1968{ 
     1969 
     1970        printk("#%s lcd_pm_status=%d\n", __func__, lcd_pm_status); 
     1971        if (lcd_pm_status == ON) 
     1972        { 
     1973        printk(KERN_WARNING "[%s] LCD is already started\n", __func__); 
     1974                return -1; 
     1975        } 
     1976 
     1977        clk_enable(fbi->clk); 
     1978        lcd_clock_status = ON; 
     1979 
     1980    mdelay(1); 
     1981 
     1982        s3c6410_pm_do_restore(s3c_lcd_save, ARRAY_SIZE(s3c_lcd_save)); 
     1983 
     1984    s3cfb_set_gpio(); 
     1985    s3cfb_start_lcd(); 
     1986 
     1987    lcd_pm_status = ON; 
     1988 
     1989    s3cfb_set_backlight_power(ON); 
     1990 
     1991    return 0; 
     1992} 
     1993 
     1994int s3cfb_is_clock_on(void) 
     1995{ 
     1996        return lcd_clock_status; 
     1997} 
     1998 
     1999void s3cfb_enable_clock_power(void) 
     2000{ 
     2001        struct early_suspend *early_suspend_ptr = get_earlysuspend_ptr(); 
     2002        s3c_fb_info_t *info = container_of(early_suspend_ptr, s3c_fb_info_t, early_suspend); 
     2003        printk("#%s lcd_pm_status=%d\n", __func__, lcd_pm_status); 
     2004 
     2005        s3cfb_resume_sub(info); 
     2006 
     2007} 
     2008 
     2009 
    19122010#ifdef CONFIG_HAS_EARLYSUSPEND 
    1913 static int lcd_pm_status = 0; 
    1914 static int lcd_clock_status = 1; 
    1915 int lcd_late_resume = 1; 
    1916  
    1917 static int s3cfb_suspend_sub(s3c_fb_info_t *fbi) 
    1918 { 
    1919  
    1920  
    1921         s3c6410_pm_do_save(s3c_lcd_save, ARRAY_SIZE(s3c_lcd_save)); 
    1922  
    1923         /* for Idle Current GPIO Setting */ 
    1924         __raw_writel(0x55555555, S3C64XX_GPICON); 
    1925         __raw_writel(0x0, S3C64XX_GPIDAT); 
    1926         __raw_writel(0x55555555, S3C64XX_GPIPUD); 
    1927         __raw_writel(0x55555555, S3C64XX_GPJCON); 
    1928         __raw_writel(0x0, S3C64XX_GPJDAT); 
    1929         __raw_writel(0x55555555, S3C64XX_GPJPUD); 
    1930  
    1931         /* sleep before disabling the clock, we need to ensure 
    1932          * the LCD DMA engine is not going to get back on the bus 
    1933          * before the clock goes off again (bjd) */ 
    1934  
    1935         msleep(1); //already breaking up 
    1936         clk_disable(fbi->clk); 
    1937  
    1938  
    1939  
    1940  
    1941 #ifdef USE_LCD_DOMAIN_GATING 
    1942      // s3c_set_normal_cfg(S3C64XX_DOMAIN_F, S3C64XX_LP_MODE, S3C64XX_LCD); 
    1943 #endif /* USE_LCD_DOMAIN_GATING */ 
    1944  
    1945  
    1946  
    1947         return 0; 
    1948 } 
    1949  
    1950 static int s3cfb_resume_sub(s3c_fb_info_t *fbi) 
    1951 { 
    1952  
    1953 #ifdef USE_LCD_DOMAIN_GATING 
    1954         s3c_set_normal_cfg(S3C64XX_DOMAIN_F, S3C64XX_ACTIVE_MODE, S3C64XX_LCD); 
    1955 //        if(s3c_wait_blk_pwr_ready(S3C64XX_BLK_F)) { 
    1956 //               printk(KERN_ERR "[%s] Domain F is not ready\n", __func__); 
    1957 //                return -1; 
    1958 //        } 
    1959 #endif /* USE_LCD_DOMAIN_GATING */ 
    1960  
    1961         clk_enable(fbi->clk); 
    1962         s3c6410_pm_do_restore(s3c_lcd_save, ARRAY_SIZE(s3c_lcd_save)); 
    1963         s3cfb_set_gpio(); 
    1964         s3cfb_start_lcd(); 
    1965         return 0; 
    1966 } 
    1967  
    1968 int s3cfb_is_clock_on(void) 
    1969 { 
    1970         return lcd_clock_status; 
    1971 } 
    1972  
    1973 void s3cfb_enable_clock_power(void) 
    1974 { 
    1975         struct early_suspend *early_suspend_ptr; 
    1976          
    1977         early_suspend_ptr = get_earlysuspend_ptr(); 
    1978  
    1979         s3c_fb_info_t *info = container_of(early_suspend_ptr, s3c_fb_info_t, early_suspend); 
    1980         s3cfb_resume_sub(info); 
    1981  
    1982         lcd_clock_status = 1; 
    1983         lcd_pm_status = 1; 
    1984 } 
    19852011 
    19862012void s3cfb_early_suspend(struct early_suspend *h) 
     
    19902016         
    19912017        printk("#%s\n", __func__); 
    1992          
    1993         lcd_late_resume = 0; 
    19942018 
    19952019        s3cfb_suspend_sub(info); 
    1996         lcd_clock_status = 0;  
    1997         lcd_pm_status = 0; 
    1998 } 
    1999  
    2000 #define MAX8698_ID              0xCC 
    2001  
    2002 #define ONOFF2                  0x01 
    2003  
    2004 #define ONOFF2_ELDO6    (0x01 << 7) 
    2005 #define ONOFF2_ELDO7    (0x03 << 6) 
     2020 
     2021} 
     2022 
    20062023void s3cfb_late_resume(struct early_suspend *h) 
    20072024{ 
    20082025        s3c_fb_info_t *info = container_of(h, s3c_fb_info_t, early_suspend); 
    2009         u8 data; 
    20102026 
    20112027        printk("#%s\n", __func__); 
    20122028 
    2013         /* Power Enable */ //CAUSES FLASH WHEN TURNING ON WITH LATE RESUME, TRY WITH LEAVING?) 
    2014         if(pmic_read(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    2015                 printk(KERN_ERR "LCD POWER CONTROL can't read the status from PMIC\n"); 
    2016                 return -1; 
    2017         } 
    2018         data |= (ONOFF2_ELDO6 | ONOFF2_ELDO7); 
    2019                  
    2020         if(pmic_write(MAX8698_ID, ONOFF2, &data, 1) != PMIC_PASS) { 
    2021                 printk(KERN_ERR "LCD POWER CONTROL can't write the command to PMIC\n"); 
    2022                 return -1; 
    2023                 }  
    2024  
    2025         if (lcd_pm_status == 0) { 
    2026                 s3cfb_resume_sub(info); 
    2027         } 
    2028  
    2029         lcd_clock_status = 1; 
    2030         lcd_late_resume = 1; 
    2031 } 
     2029#ifdef USE_LCD_DOMAIN_GATING 
     2030        if (s3cfb_domain_gating_wait() < 0) 
     2031        { 
     2032        printk(KERN_ERR "[%s] Domain F is not ready\n", __func__); 
     2033        return; 
     2034        } 
     2035#endif /* USE_LCD_DOMAIN_GATING */ 
     2036 
     2037        s3cfb_resume_sub(info); 
     2038 
     2039} 
     2040 
    20322041/* 
    20332042 *  Suspend 
     
    20352044int s3cfb_suspend(struct platform_device *dev, pm_message_t state) 
    20362045{ 
     2046        printk("#%s\n", __func__); 
     2047 
     2048#ifdef USE_LCD_DOMAIN_GATING 
     2049        s3cfb_domain_gating_off(); 
     2050#endif /* USE_LCD_DOMAIN_GATING */ 
     2051 
     2052        return 0; 
     2053} 
     2054 
     2055/* 
     2056 *  Resume 
     2057 */ 
     2058int s3cfb_resume(struct platform_device *dev) 
     2059{ 
     2060        printk("#%s\n", __func__); 
     2061 
     2062#ifdef USE_LCD_DOMAIN_GATING 
     2063        s3cfb_domain_gating_on(); 
     2064#endif /* USE_LCD_DOMAIN_GATING */ 
     2065 
     2066        return 0; 
     2067} 
     2068 
     2069#else   /* CONFIG_HAS_EARLYSUSPEND */ 
     2070 
     2071/* 
     2072 *  Suspend 
     2073 */ 
     2074int s3cfb_suspend(struct platform_device *dev, pm_message_t state) 
     2075{ 
    20372076 
    20382077        struct fb_info *fbinfo = platform_get_drvdata(dev); 
     
    20402079         
    20412080        printk("#%s\n", __func__); 
    2042  
    2043         if (lcd_pm_status != 0) { 
    2044                 s3cfb_suspend_sub(info); 
    2045         } 
    2046  
    2047         lcd_clock_status = 0; 
     2081        s3cfb_suspend_sub(info); 
    20482082 
    20492083        return 0; 
     
    20622096        s3cfb_resume_sub(info); 
    20632097 
    2064         lcd_clock_status = 1; 
    2065         lcd_pm_status = 1; 
    2066  
    2067         return 0; 
    2068 } 
    2069  
    2070 /* 
    2071  * shutdown 
    2072  */ 
    2073 extern void lcd_power_ctrl(s32 value); 
    2074 int s3cfb_shutdown(struct platform_device *dev) 
    2075 { 
    2076         printk("s3cfb_shutdown \n"); 
    2077         lcd_power_ctrl(0); 
    2078         return 0; 
    2079 } 
    2080 #else 
    2081  
    2082 /* 
    2083  *  Suspend 
    2084  */ 
    2085 int s3cfb_suspend(struct platform_device *dev, pm_message_t state) 
    2086 { 
    2087  
    2088         struct fb_info *fbinfo = platform_get_drvdata(dev); 
    2089         s3c_fb_info_t *info = fbinfo->par; 
    2090          
    2091         s3cfb_suspend_sub(info); 
    2092  
    2093         return 0; 
    2094 } 
    2095  
    2096 /* 
    2097  *  Resume 
    2098  */ 
    2099 int s3cfb_resume(struct platform_device *dev) 
    2100 { 
    2101         struct fb_info *fbinfo = platform_get_drvdata(dev); 
    2102         s3c_fb_info_t *info = fbinfo->par; 
    2103  
    2104         s3cfb_resume_sub(info); 
    2105  
    2106         return 0; 
    2107 } 
     2098        return 0; 
     2099} 
     2100 
     2101#endif  /* CONFIG_HAS_EARLYSUSPEND */ 
    21082102 
    21092103/* 
     
    21122106int s3cfb_shutdown(struct platform_device *dev) 
    21132107{ 
    2114         lcd_power_ctrl(0); 
    2115 } 
    2116 #endif  /* CONFIG_HAS_EARLYSUSPEND */ 
     2108        struct fb_info *fbinfo = platform_get_drvdata(dev); 
     2109        s3c_fb_info_t *info = fbinfo->par; 
     2110 
     2111        s3cfb_suspend_sub(info); 
     2112 
     2113        return 0; 
     2114} 
    21172115 
    21182116#else 
Note: See TracChangeset for help on using the changeset viewer.