static void pmic_green_led_on(struct work_struct *work)
{
#if defined CONFIG_GPIO_34_49_CTRL_LED || defined CONFIG_GPIO_10_11_CTRL_LED ||defined(CONFIG_USE_PM_GPIO_CTRL_LED)
//not use b_led
#else
struct BLINK_LED_data *b_led = container_of(work, struct BLINK_LED_data, work_led_on);
#endif
#if defined (CONFIG_GPIO_10_11_CTRL_LED)
gpio_direction_output(GPIO_GREEN_LIGHT_CTRL, 1);
#elif defined (CONFIG_GPIO_34_49_CTRL_LED)
pmic_secure_mpp_config_i_sink(GPIO_GREEN_LIGHT_CTRL,
PM_MPP__I_SINK__LEVEL_5mA, PM_MPP__I_SINK__SWITCH_ENA);
#elif defined(CONFIG_USE_PM_GPIO_CTRL_LED)
pmic_gpio_direction_output(GPIO_GREEN_LIGHT_CTRL);
pmic_gpio_set_value(GPIO_GREEN_LIGHT_CTRL,1);
#else
//pmic_set_led_intensity(LED_LCD, b_led->led.brightness / MAX_PMIC_BL_LEVEL);
pmic_secure_mpp_config_i_sink(PM_MPP_8,
b_led->led.brightness / MAX_PMIC_BL_LEVEL, PM_MPP__I_SINK__SWITCH_ENA);
#endif
//printk(KERN_NOTICE "PM_DEBUG_MXP:Green led on.\r\n");
}
static void msm_led_brightness_set_percent(struct pdm_led_data *led,
int duty_per)
{
//pr_emerg("[RED LED] %s (%d)\n", __func__, duty_per);
//pmapp_red_led_set_brightness(duty_per);
if (duty_per){
if (!cur_brightness){
if(dimming_brightness)
{
pmapp_red_led_set_brightness(0);
dimming_brightness=0;
}
pmic_secure_mpp_config_i_sink(PM_MPP_8, PM_MPP__I_SINK__LEVEL_5mA,1);
cur_brightness = 1;
}
}
else {
if(dimming_brightness)
{
pmapp_red_led_set_brightness(0);
dimming_brightness=0;
}
else if (cur_brightness)
{
pmic_secure_mpp_config_i_sink(PM_MPP_8, PM_MPP__I_SINK__LEVEL_5mA,0);
cur_brightness = 0;
}
}
}
static void mipi_chimei_set_backlight(struct msm_fb_data_type *mfd)
{
struct mipi_panel_info *mipi;
static int bl_level_old;
mipi = &mfd->panel_info.mipi;
if (mfd->panel_power_on != TRUE) {
LCD_PRINTK(1, "%s: panel_power is off\n", __func__);
return;
}
if (bl_level_old == mfd->bl_level)
{
LCD_PRINTK(1, "%s: ## bl_level_old == bl_level , %d\n", __func__, bl_level_old);
return;
}
LCD_PRINTK(1, "%s(): bl_level= %d\n", __func__, mfd->bl_level);
wr_disbv[1] = (unsigned char)(mfd->bl_level);
down(&mfd->dma->mutex);
mipi_dsi_cmds_tx(mfd, &chimei_tx_buf, chimei_cmd_backlight_cmds,
ARRAY_SIZE(chimei_cmd_backlight_cmds));
up(&mfd->dma->mutex);
bl_level_old = mfd->bl_level;
#if FB_MSM_MIPI_DSI_CHIMEI_PWMINFO_PES
system_bl_level_old = mfd->bl_level;
#endif
if (!atomic_read(&cap_bkl_emmode_enable)) {
unsigned int cap_key_bl_level = mfd->bl_level;
cap_key_bl_level /= 10;
cap_key_bl_level = (cap_key_bl_level > 8) ? 8 : cap_key_bl_level;
if (cap_key_bl_level == 0)
{
pmic_secure_mpp_config_i_sink(PM_MPP_3, PM_MPP__I_SINK__LEVEL_20mA, PM_MPP__I_SINK__SWITCH_DIS);
if (capkey_bl_on)
{
PM_LOG_EVENT(PM_LOG_OFF, PM_LOG_BL_KEYPAD);
capkey_bl_on=0;
}
}
else
{
pmic_secure_mpp_config_i_sink(PM_MPP_3, (cap_key_bl_level-1), PM_MPP__I_SINK__SWITCH_ENA);
if(!capkey_bl_on)
{
PM_LOG_EVENT(PM_LOG_ON, PM_LOG_BL_KEYPAD);
capkey_bl_on=1;
}
}
}
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int on_off;
int brightness;
/* debug mesg */
printk(KERN_INFO " LED DEBUG: Value is %d\n", value);
if (value == 0)
on_off = (int)PM_MPP__I_SINK__SWITCH_DIS;
else
on_off = (int)PM_MPP__I_SINK__SWITCH_ENA;
switch (value) {
case 5:
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
case 10:
brightness = PM_MPP__I_SINK__LEVEL_10mA;
break;
case 15:
brightness = PM_MPP__I_SINK__LEVEL_15mA;
break;
case 20:
brightness = PM_MPP__I_SINK__LEVEL_20mA;
break;
case 25:
brightness = PM_MPP__I_SINK__LEVEL_25mA;
break;
case 30:
brightness = PM_MPP__I_SINK__LEVEL_30mA;
break;
case 35:
brightness = PM_MPP__I_SINK__LEVEL_35mA;
break;
case 40:
brightness = PM_MPP__I_SINK__LEVEL_40mA;
break;
default:/* LGE_CHANGE [[email protected]] 20120223 : LED Current Reduce 25 -> 5mA */
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
}
if (lge_bd_rev == LGE_REV_A) {
/* LED power(MPP pin) use
*REV.A
*EU :MPP3, MPP4
*MPCS :MPP4
*/
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_4, brightness, (enum mpp_i_sink_switch)on_off);
} else if (lge_bd_rev >= LGE_REV_B) {
/* LED power(MPP pin) use
*REV.B
*EU :MPP3
*MPCS :MPP3
*/
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_3, brightness, (enum mpp_i_sink_switch)on_off);
}
}
static void kpd_bl_ctrl(unsigned int onoff)
{
int ret;
if (onoff) {
ret=pmic_secure_mpp_config_i_sink(PM_MPP_8,PM_MPP__I_SINK__LEVEL_5mA,PM_MPP__I_SINK__SWITCH_ENA);
} else {
ret=pmic_secure_mpp_config_i_sink(PM_MPP_8,PM_MPP__I_SINK__LEVEL_5mA,PM_MPP__I_SINK__SWITCH_DIS);
}
if (ret)
printk("kpd_bl_ctrl led fail ret=%d\n",ret);
return;
}
static void pmic_green_led_off(struct work_struct *work)
{
#if defined (CONFIG_GPIO_10_11_CTRL_LED)
gpio_direction_output(GPIO_GREEN_LIGHT_CTRL, 0);
#elif defined (CONFIG_GPIO_34_49_CTRL_LED)
pmic_secure_mpp_config_i_sink(GPIO_GREEN_LIGHT_CTRL,
PM_MPP__I_SINK__LEVEL_5mA, PM_MPP__I_SINK__SWITCH_DIS);
#elif defined(CONFIG_USE_PM_GPIO_CTRL_LED)
pmic_gpio_direction_output(GPIO_GREEN_LIGHT_CTRL);
pmic_gpio_set_value(GPIO_GREEN_LIGHT_CTRL,0);
#else
//pmic_set_led_intensity(LED_LCD, LED_OFF);
pmic_secure_mpp_config_i_sink(PM_MPP_8, 0, PM_MPP__I_SINK__SWITCH_DIS);
#endif
//printk(KERN_NOTICE "PM_DEBUG_MXP:Green led off.\r\n");
}
static ssize_t mipi_chimei_capbkl_write(
struct file *file,
const char __user *buff,
size_t count,
loff_t *ppos)
{
uint32 val, cnt;
if (count >= sizeof(debug_buf))
return -EFAULT;
if (copy_from_user(debug_buf, buff, count))
return -EFAULT;
debug_buf[count] = 0;
sscanf(debug_buf, "%d %d", &val, &cnt);
if (val > 7 || val<0)
{
printk(KERN_ERR "Capkey backlight value should be 0~7, %d\n",val);
return -EINVAL;
}
LCD_PRINTK(1, "Capkey backlight value[0~7] is %d\n", val);
if (val == 7)
{
atomic_set(&cap_bkl_emmode_enable,1);
printk(KERN_ERR "Capkey backlight is locked in EM_mode\n");
}
if (val == 0)
{
atomic_set(&cap_bkl_emmode_enable,0);
pmic_secure_mpp_config_i_sink(PM_MPP_3, PM_MPP__I_SINK__LEVEL_20mA, PM_MPP__I_SINK__SWITCH_DIS);
}
else {
pmic_secure_mpp_config_i_sink(PM_MPP_3, val, PM_MPP__I_SINK__SWITCH_ENA);
}
return count;
}
static void mipi_chimei_set_backlight(struct msm_fb_data_type *mfd)
{
int ret = -EPERM;
int bl_level;
LCD_PRINTK(1, "%s(): bl_level= %d, [PMIC]\n", __func__, mfd->bl_level);
bl_level = mfd->bl_level;
if (mipi_chimei_pdata && mipi_chimei_pdata->pmic_backlight)
ret = mipi_chimei_pdata->pmic_backlight(bl_level);
else
printk(KERN_ERR "%s: Backlight level set failed\n", __func__);
#if FB_MSM_MIPI_DSI_CHIMEI_PWMINFO_PES
system_bl_level_old = mfd->bl_level;
#endif
if (!atomic_read(&cap_bkl_emmode_enable)) {
unsigned int cap_key_bl_level = mfd->bl_level;
cap_key_bl_level /= 10;
cap_key_bl_level = (cap_key_bl_level > 8) ? 8 : cap_key_bl_level;
if (cap_key_bl_level == 0)
{
pmic_secure_mpp_config_i_sink(PM_MPP_3, PM_MPP__I_SINK__LEVEL_20mA, PM_MPP__I_SINK__SWITCH_DIS);
if (capkey_bl_on)
{
PM_LOG_EVENT(PM_LOG_OFF, PM_LOG_BL_KEYPAD);
capkey_bl_on=0;
}
}
else
{
pmic_secure_mpp_config_i_sink(PM_MPP_3, (cap_key_bl_level-1), PM_MPP__I_SINK__SWITCH_ENA);
if(!capkey_bl_on)
{
PM_LOG_EVENT(PM_LOG_ON, PM_LOG_BL_KEYPAD);
capkey_bl_on=1;
}
}
}
}
/* add led device for VS660 Rev.D by younchan.kim 2010-05-27 */
static void pmic_mpp_isink_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int mpp_number;
int on_off;
int i;
int brightness;
if (!strcmp(led_cdev->name ,"button-backlight"))
mpp_number = (int)PM_MPP_19;
else
return;
printk (" LED DEBUG: Value is %d \n",value);
if(value == 0)
on_off = (int)PM_MPP__I_SINK__SWITCH_DIS;
else
on_off = (int)PM_MPP__I_SINK__SWITCH_ENA;
switch(value){
case 5:
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
case 10 :
brightness = PM_MPP__I_SINK__LEVEL_10mA;
break;
case 15 :
brightness = PM_MPP__I_SINK__LEVEL_15mA;
break;
case 20 :
brightness = PM_MPP__I_SINK__LEVEL_20mA;
break;
case 25 :
brightness = PM_MPP__I_SINK__LEVEL_25mA;
break;
case 30 :
brightness = PM_MPP__I_SINK__LEVEL_30mA;
break;
case 35 :
brightness = PM_MPP__I_SINK__LEVEL_35mA;
break;
case 40 :
brightness = PM_MPP__I_SINK__LEVEL_40mA;
break;
default :
brightness = PM_MPP__I_SINK__LEVEL_15mA;
break;
}
for(i=0; i<4; i++){
pmic_secure_mpp_config_i_sink((enum mpp_which)mpp_number,
brightness, (enum mpp_i_sink_switch)on_off);
mpp_number++;
}
}
static ssize_t brightness_dimming_write(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
//struct led_classdev *led_cdev = dev_get_drvdata(dev);
static unsigned long red_led_brightness;
if (strict_strtoul(buf, 10, &red_led_brightness))
return -EINVAL;
if(red_led_brightness>0)
{
if(!dimming_brightness)
{
if (cur_brightness)
{
pmic_secure_mpp_config_i_sink(PM_MPP_8, PM_MPP__I_SINK__LEVEL_5mA,0);
cur_brightness=0;
}
pmapp_red_led_set_brightness(100);
dimming_brightness=1;
}
}
else
{
if(dimming_brightness)
{
pmapp_red_led_set_brightness(0);
dimming_brightness=0;
}
else if (cur_brightness)
{
pmic_secure_mpp_config_i_sink(PM_MPP_8, PM_MPP__I_SINK__LEVEL_5mA,0);
cur_brightness = 0;
}
}
return count;
}
//////////////////////////////////
// LED Control
//////////////////////////////////
static void cam12mp_led_control(int ctrl)
{
switch (ctrl) {
case LED_OFF:
if(cam12mp_ctrl->model == DEV_MODEL_NO_0 || cam12mp_ctrl->model == DEV_MODEL_NO_1) {
pmic_set_led_intensity(LED_LCD, 0);
pmic_set_led_intensity(LED_KEYPAD, 0);
} else {
pmic_secure_mpp_config_i_sink(PM_MPP_13,cam12mp_ctrl->led,
PM_MPP__I_SINK__SWITCH_DIS);
pmic_secure_mpp_config_i_sink(PM_MPP_18,cam12mp_ctrl->led,
PM_MPP__I_SINK__SWITCH_DIS);
}
if ( vreg_disable(vreg_get(NULL, "boost"))) // VREG_5V
LOGE("%s: vreg_5Vdisable failed !\n", __func__);
break;
case LED_LOW:
case LED_HIGH:
if ( vreg_enable(vreg_get(NULL, "boost"))) // VREG_5V
LOGE("%s: vreg_5V enable failed !\n", __func__);
mdelay(1);
if(cam12mp_ctrl->model == DEV_MODEL_NO_0 || cam12mp_ctrl->model == DEV_MODEL_NO_1) {
pmic_set_led_intensity(LED_LCD, 1);
pmic_set_led_intensity(LED_KEYPAD, 1);
} else {
cam12mp_ctrl->led = ctrl == LED_LOW ? PM_MPP__I_SINK__LEVEL_10mA :
PM_MPP__I_SINK__LEVEL_15mA;
pmic_secure_mpp_config_i_sink(PM_MPP_13, cam12mp_ctrl->led,
PM_MPP__I_SINK__SWITCH_ENA);
pmic_secure_mpp_config_i_sink(PM_MPP_18, cam12mp_ctrl->led,
PM_MPP__I_SINK__SWITCH_ENA);
}
break;
}
}
static void set_blue_brightness(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret = 0;
RGB_PRINT("%s: value = %d\n",__func__, value);
ret = pmic_secure_mpp_config_i_sink(PM_MPP_20, PM_MPP__I_SINK__LEVEL_5mA, \
(!!value) ? PM_MPP__I_SINK__SWITCH_ENA : PM_MPP__I_SINK__SWITCH_DIS);
if(ret)
{
RGB_PRINT("%s: failed\n",__func__);
return;
}
RGB_PRINT("%s: success\n",__func__);
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int on_off;
int brightness;
/* debug mesg */
printk(KERN_INFO " LED DEBUG: Value is %d\n", value);
if (value == 0)
on_off = (int)PM_MPP__I_SINK__SWITCH_DIS;
else
on_off = (int)PM_MPP__I_SINK__SWITCH_ENA;
switch (value) {
case 5:
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
case 10:
brightness = PM_MPP__I_SINK__LEVEL_10mA;
break;
case 15:
brightness = PM_MPP__I_SINK__LEVEL_15mA;
break;
case 20:
brightness = PM_MPP__I_SINK__LEVEL_20mA;
break;
case 25:
brightness = PM_MPP__I_SINK__LEVEL_25mA;
break;
case 30:
brightness = PM_MPP__I_SINK__LEVEL_30mA;
break;
case 35:
brightness = PM_MPP__I_SINK__LEVEL_35mA;
break;
case 40:
brightness = PM_MPP__I_SINK__LEVEL_40mA;
break;
default:
//brightness = PM_MPP__I_SINK__LEVEL_25mA;
brightness = PM_MPP__I_SINK__LEVEL_15mA;/* LGE_CHANGE_S : [email protected] [2011-12-02] LED brightness chnanged 25mA --> 5mA -> 15mA */
break;
}
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_3, brightness, (enum mpp_i_sink_switch)on_off);
}
static int debug_secure_mpp_config_i_sink(char *buf, int size)
{
enum mpp_which which;
enum mpp_i_sink_level level;
enum mpp_i_sink_switch onoff;
int cnt;
cnt = sscanf(buf, "%u %u %u", &which, &level, &onoff);
if (cnt < 3) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_secure_mpp_config_i_sink(which, level, onoff) < 0)
return -EFAULT;
return size;
}
static void set_green_brightness(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret = 0;
RGB_PRINT("%s: value = %d\n",__func__, value);
/* because T2 touch_pannel wrong, we need adjust green LED current to 10 mA*/
/* In U8150 PP1, we can adjust green LED current back to 5 mA*/
ret = pmic_secure_mpp_config_i_sink(PM_MPP_16, PM_MPP__I_SINK__LEVEL_5mA, \
(!!value) ? PM_MPP__I_SINK__SWITCH_ENA : PM_MPP__I_SINK__SWITCH_DIS);
if(ret)
{
RGB_PRINT("%s: failed\n",__func__);
return;
}
RGB_PRINT("%s: success\n",__func__);
}
static int mipi_chimei_lcd_off(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
LCD_PRINTK(0, "%s()\n", __func__);
#ifdef CONFIG_FB_MSM_BACKLIGHT_HX8363A
#else
if (mipi_chimei_pdata && mipi_chimei_pdata->pmic_backlight)
mipi_chimei_pdata->pmic_backlight(0);
else
printk(KERN_ERR "%s: Backlight level set failed\n", __func__);
#endif
mipi_dsi_cmds_tx(mfd, &chimei_tx_buf, chimei_display_off_cmds,
ARRAY_SIZE(chimei_display_off_cmds));
if (!atomic_read(&cap_bkl_emmode_enable))
{
if (capkey_bl_on)
{
pmic_secure_mpp_config_i_sink(PM_MPP_3, PM_MPP__I_SINK__LEVEL_20mA, PM_MPP__I_SINK__SWITCH_DIS);
PM_LOG_EVENT(PM_LOG_OFF, PM_LOG_BL_KEYPAD);
capkey_bl_on=0;
}
}
PM_LOG_EVENT (PM_LOG_OFF, PM_LOG_BL_LCD);
LCD_PRINTK(1, "%s()--\n", __func__);
return 0;
}
static void set_blue_brightness(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret = 0;
RGB_PRINT("%s: value = %d\n",__func__, value);
/*< DTS2012021602342 zhongjinrong 20120224 begin */
#ifdef CONFIG_ARCH_MSM7X27A
/* DTS2012021602342 zhongjinrong 20120224 end >*/
ret = pmic_secure_mpp_config_i_sink(PM_MPP_8, PM_MPP__I_SINK__LEVEL_5mA, \
(!!value) ? PM_MPP__I_SINK__SWITCH_ENA : PM_MPP__I_SINK__SWITCH_DIS);
#else
ret = pmic_set_low_current_led_intensity(PM_LOW_CURRENT_LED_DRV2, (!!value)? LEVEL : 0);
#endif
if(ret)
{
RGB_PRINT("%s: failed,ret=%d\n",__func__,ret);
return;
}
RGB_PRINT("%s: success\n",__func__);
}
static void set_green_brightness(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret = 0;
RGB_PRINT("%s: value = %d\n",__func__, value);
/*< DTS2011122703714 duanfei 20111227 begin */
/*< DTS2012021602342 zhongjinrong 20120224 begin */
#ifdef CONFIG_ARCH_MSM7X27A
/* DTS2012021602342 zhongjinrong 20120224 end >*/
if (HW_DS == board_ds)
{
/*< DTS2012021602342 zhongjinrong 20120224 begin */
/* <DTS2012020906039 liguosheng 20120218 begin */
/*ap side control the gpio*/
gpio_tlmm_config(GPIO_CFG(GPIO_LED_GREEN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
/* DTS2012020906039 liguosheng 20120218 end> */
/* DTS2012021602342 zhongjinrong 20120224 end >*/
ret = gpio_direction_output(GPIO_LED_GREEN,(!!value) ? LED_ON : LED_OFF);
}
else
{
ret = pmic_secure_mpp_config_i_sink(PM_MPP_5, PM_MPP__I_SINK__LEVEL_5mA, \
(!!value) ? PM_MPP__I_SINK__SWITCH_ENA : PM_MPP__I_SINK__SWITCH_DIS);
}
/* DTS2011122703714 duanfei 20111227 end >*/
#else
ret = pmic_set_low_current_led_intensity(PM_LOW_CURRENT_LED_DRV1, (!!value)? LEVEL : 0);
#endif
if(ret)
{
RGB_PRINT("%s: failed,ret=%d\n",__func__,ret);
return;
}
RGB_PRINT("%s: success\n",__func__);
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
#if defined(CONFIG_MACH_MSM7X27A_U0) || defined (CONFIG_MACH_MSM7X25A_M4)
int on_off;
int brightness;
/* debug mesg */
printk(KERN_INFO " LED DEBUG: Value is %d\n", value);
if (value == 0)
on_off = (int)PM_MPP__I_SINK__SWITCH_DIS;
else
on_off = (int)PM_MPP__I_SINK__SWITCH_ENA;
#if defined (CONFIG_MACH_MSM7X25A_M4)
brightness = PM_MPP__I_SINK__LEVEL_10mA;
#else
brightness = PM_MPP__I_SINK__LEVEL_5mA;
#endif
#if 0
switch (value) {
case 5:
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
case 10:
brightness = PM_MPP__I_SINK__LEVEL_10mA;
break;
case 15:
brightness = PM_MPP__I_SINK__LEVEL_15mA;
break;
case 20:
brightness = PM_MPP__I_SINK__LEVEL_20mA;
break;
case 25:
brightness = PM_MPP__I_SINK__LEVEL_25mA;
break;
case 30:
brightness = PM_MPP__I_SINK__LEVEL_30mA;
break;
case 35:
brightness = PM_MPP__I_SINK__LEVEL_35mA;
break;
case 40:
brightness = PM_MPP__I_SINK__LEVEL_40mA;
break;
default:/* LGE_CHANGE [[email protected]] 20120223 : LED Current Reduce 25 -> 5mA */
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
}
if (lge_bd_rev == LGE_REV_A) {
/* LED power(MPP pin) use
*REV.A
*EU :MPP3, MPP4
*MPCS :MPP4
*/
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_4, brightness, (enum mpp_i_sink_switch)on_off);
} else if (lge_bd_rev >= LGE_REV_B) {
/* LED power(MPP pin) use
*REV.B
*EU :MPP3
*MPCS :MPP3
*/
#endif
#if defined (CONFIG_MACH_MSM7X25A_M4)
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_7, brightness, (enum mpp_i_sink_switch)on_off);
#else
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_3, brightness, (enum mpp_i_sink_switch)on_off);
#endif
// }
#else //CONFIG_MACH_MSM7X27A_U0
int ret;
ret = pmic_set_led_intensity(LED_KEYPAD, value / MAX_KEYPAD_BL_LEVEL);
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
#endif
}
static struct led_classdev msm_kp_bl_led = {
#if defined(CONFIG_MACH_MSM7X27A_U0) || defined (CONFIG_MACH_MSM7X25A_M4)
.name = "button-backlight",
#else
.name = "keyboard-backlight",
#endif
.brightness_set = msm_keypad_bl_led_set,
.brightness = LED_OFF,
};
static int msm_pmic_led_probe(struct platform_device *pdev)
{
int rc;
rc = led_classdev_register(&pdev->dev, &msm_kp_bl_led);
if (rc) {
dev_err(&pdev->dev, "unable to register led class driver\n");
return rc;
}
#if 0//defined(CONFIG_MACH_MSM7X27A_U0)
/* LGE_CHANGE_S: [[email protected]]: 2012-03-23,
Enabled key backlight leds till idle screen */
msm_keypad_bl_led_set(&msm_kp_bl_led, 5); /* 5mA Brightness */
#else//CONFIG_MACH_MSM7X27A_U0
msm_keypad_bl_led_set(&msm_kp_bl_led, LED_OFF);
#endif
return rc;
}
static int __devexit msm_pmic_led_remove(struct platform_device *pdev)
{
led_classdev_unregister(&msm_kp_bl_led);
return 0;
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
//LGE_CHANGE_S, [[email protected]] , 2011-12-08
#if 0 /* original */
int ret;
ret = pmic_set_led_intensity(LED_KEYPAD, value / MAX_KEYPAD_BL_LEVEL);
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
#else
int on_off;
int brightness;
/* debug mesg */
printk(KERN_INFO " LED DEBUG: Value is %d\n", value);
if (value == 0)
on_off = (int)PM_MPP__I_SINK__SWITCH_DIS;
else
on_off = (int)PM_MPP__I_SINK__SWITCH_ENA;
switch (value) {
case 5:
brightness = PM_MPP__I_SINK__LEVEL_5mA;
break;
case 10:
brightness = PM_MPP__I_SINK__LEVEL_10mA;
break;
case 15:
brightness = PM_MPP__I_SINK__LEVEL_15mA;
break;
case 20:
brightness = PM_MPP__I_SINK__LEVEL_20mA;
break;
case 25:
brightness = PM_MPP__I_SINK__LEVEL_25mA;
break;
case 30:
brightness = PM_MPP__I_SINK__LEVEL_30mA;
break;
case 35:
brightness = PM_MPP__I_SINK__LEVEL_35mA;
break;
case 40:
brightness = PM_MPP__I_SINK__LEVEL_40mA;
break;
default:
#if defined(CONFIG_MACH_MSM7X25A_M4EU_REV_B) || defined(CONFIG_MACH_MSM7X25A_M4BR_REV_B)
brightness = PM_MPP__I_SINK__LEVEL_10mA;
#else
brightness = PM_MPP__I_SINK__LEVEL_5mA;
#endif
break;
}
#endif
#if !defined(CONFIG_MACH_MSM7X25A_M4)
if (lge_bd_rev == LGE_REV_A) {
/* LED power(MPP pin) use
*REV.A
*EU :MPP3, MPP4
*MPCS :MPP4
*/
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_4, brightness, (enum mpp_i_sink_switch)on_off);
} else if (lge_bd_rev >= LGE_REV_B) {
/* LED power(MPP pin) use
*REV.B
*EU :MPP3
*MPCS :MPP3
*/
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_3, brightness, (enum mpp_i_sink_switch)on_off);
}
#else
pmic_secure_mpp_config_i_sink((enum mpp_which)PM_MPP_7, brightness, (enum mpp_i_sink_switch)on_off);
#endif
//LGE_CHANGE_E, [[email protected]] , 2011-12-08
}
static void msm_pmic_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
if(led_not_suspend_flag ==0)
{
printk(KERN_NOTICE "PM_DEBUG_MXP:Led colour updated.\r\n");
#ifdef CONFIG_ZTE_NLED_BLINK_WHILE_APP_SUSPEND
msm_pmic_led_config_while_app2sleep( STATUS_LED->blink_led[0].led.brightness,
STATUS_LED->blink_led[1].led.brightness, STATUS_LED->blink_led[0].blink_flag,
STATUS_LED->blink_led[1].blink_flag, ZTE_PROC_COMM_CMD3_NLED_BLINK_ENABLE);
#endif
}
else
{
if (!strcmp(led_cdev->name, "red"))
{
#if defined (CONFIG_GPIO_10_11_CTRL_LED)
if(value == LED_OFF)
{
ret = gpio_direction_output(GPIO_RED_LIGHT_CTRL, 0);
}
else
{
ret = gpio_direction_output(GPIO_RED_LIGHT_CTRL, 1);
}
#elif defined (CONFIG_GPIO_34_49_CTRL_LED)
if(value == LED_OFF)
{
ret = pmic_secure_mpp_config_i_sink(GPIO_RED_LIGHT_CTRL,
PM_MPP__I_SINK__LEVEL_5mA, PM_MPP__I_SINK__SWITCH_DIS);
}
else
{
ret = pmic_secure_mpp_config_i_sink(GPIO_RED_LIGHT_CTRL, PM_MPP__I_SINK__LEVEL_5mA, PM_MPP__I_SINK__SWITCH_ENA);
}
#elif defined(CONFIG_USE_PM_GPIO_CTRL_LED)
if(value == LED_OFF)
{
ret = pmic_gpio_direction_output(GPIO_RED_LIGHT_CTRL);
ret = pmic_gpio_set_value(GPIO_RED_LIGHT_CTRL,0);
}
else
{
ret = pmic_gpio_direction_output(GPIO_RED_LIGHT_CTRL);
ret = pmic_gpio_set_value(GPIO_RED_LIGHT_CTRL,1);
}
#else
//ret = pmic_set_led_intensity(LED_KEYPAD, value / MAX_PMIC_BL_LEVEL);
if(value == LED_OFF)
{
ret = pmic_secure_mpp_config_i_sink(PM_MPP_3, value / MAX_PMIC_BL_LEVEL, PM_MPP__I_SINK__SWITCH_DIS);
}
else
{
ret = pmic_secure_mpp_config_i_sink(PM_MPP_3, value / MAX_PMIC_BL_LEVEL, PM_MPP__I_SINK__SWITCH_ENA);
}
#endif
}
else //green
{
#if defined (CONFIG_GPIO_10_11_CTRL_LED)
if(value == LED_OFF)
{
ret = gpio_direction_output(GPIO_GREEN_LIGHT_CTRL, 0);
}
else
{
ret = gpio_direction_output(GPIO_GREEN_LIGHT_CTRL, 1);
}
#elif defined (CONFIG_GPIO_34_49_CTRL_LED)
if(value == LED_OFF)
{
ret = pmic_secure_mpp_config_i_sink(GPIO_GREEN_LIGHT_CTRL, PM_MPP__I_SINK__LEVEL_5mA, PM_MPP__I_SINK__SWITCH_DIS);
}
else
{
ret = pmic_secure_mpp_config_i_sink(GPIO_GREEN_LIGHT_CTRL, PM_MPP__I_SINK__LEVEL_5mA, PM_MPP__I_SINK__SWITCH_ENA);
}
#elif defined(CONFIG_USE_PM_GPIO_CTRL_LED)
if(value == LED_OFF)
{
ret = pmic_gpio_direction_output(GPIO_GREEN_LIGHT_CTRL);
ret = pmic_gpio_set_value(GPIO_GREEN_LIGHT_CTRL,0);
}
else
{
ret = pmic_gpio_direction_output(GPIO_GREEN_LIGHT_CTRL);
ret = pmic_gpio_set_value(GPIO_GREEN_LIGHT_CTRL,1);
}
#else
if(value == LED_OFF)
{
ret = pmic_secure_mpp_config_i_sink(PM_MPP_8, value / MAX_PMIC_BL_LEVEL, PM_MPP__I_SINK__SWITCH_DIS);
}
else
{
ret = pmic_secure_mpp_config_i_sink(PM_MPP_8, value / MAX_PMIC_BL_LEVEL, PM_MPP__I_SINK__SWITCH_ENA);
}
#endif
}
if (ret)
dev_err(led_cdev->dev, "PM_DEBUG_MXP:LEDS:can't set pmic backlight\n");
}
}
/*configure GPIO 25 Of PIMIC as PWM to driver LED*/
int led_pwm_gpio_config(void)
{
int rc;
struct pm_gpio backlight_drv =
{
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = 0,
.out_strength = PM_GPIO_STRENGTH_HIGH,
.function = PM_GPIO_FUNC_2,
.inv_int_pol = 1,
};
if(machine_is_msm8255_u8860lp()
|| machine_is_msm8255_u8860_r()
||machine_is_msm8255_u8860_51())
{
rc = pm8xxx_gpio_config( 24, &backlight_drv);
}
else
{
rc = -1;
}
if (rc)
{
pr_err("%s LED backlight GPIO config failed\n", __func__);
return rc;
}
return 0;
}
#endif
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
#ifdef CONFIG_HUAWEI_LEDS_PMIC
int ret = 0;
/* 7x27a platform use mpp7 as keypad backlight */
#ifdef CONFIG_ARCH_MSM7X27A
if(machine_is_msm7x27a_C8820())
{
ret = pmic_secure_mpp_config_i_sink(PM_MPP_7, PM_MPP__I_SINK__LEVEL_5mA, \
(!!value) ? PM_MPP__I_SINK__SWITCH_ENA : PM_MPP__I_SINK__SWITCH_DIS);
}
else
{
/* use pwm to control the brightness of keypad backlight*/
/* make sure the led is drived by pwm when */
/* the system sleep indicator switch is on */
pmapp_button_backlight_init();
ret = pmapp_button_backlight_set_brightness(value);
}
#else
if(machine_is_msm7x30_u8800() || machine_is_msm7x30_u8800_51() || machine_is_msm8255_u8800_pro() )
{
ret = pmic_set_led_intensity(LED_KEYPAD, !( ! value));
}
else if( machine_is_msm8255_u8860lp()
|| machine_is_msm8255_u8860_r()
||machine_is_msm8255_u8860_51())
{
pwm_config(bl_pwm, LED_PWM_DUTY_LEVEL*value/NSEC_PER_USEC, LED_PWM_PERIOD/NSEC_PER_USEC);
pwm_enable(bl_pwm);
}
else if(machine_is_msm7x30_u8820()
|| (machine_is_msm8255_u8730()))
{
ret = pmic_set_mpp6_led_intensity(!( ! value));
}
/*< when the value between 0 and 255,set the key brightness is LED_BRIGHRNESS_LEVEL or set the brightness is 0 */
else if( machine_is_msm8255_u8860()
|| machine_is_msm8255_c8860()
|| machine_is_msm8255_u8860_92())
{
if(LED_BRIGHTNESS_OFF >= value || LED_PWM_LEVEL < value )
{
ret = pmic_set_keyled_intensity(LED_KEYPAD,LED_BRIGHTNESS_OFF );
}
else
{
ret = pmic_set_keyled_intensity(LED_KEYPAD, LED_BRIGHTNESS_LEVEL);
}
}
else if(machine_is_msm8255_u8680())
{
/* Set keypad led brightness level 12 for U8680 */
if(LED_BRIGHTNESS_OFF >= value || LED_PWM_LEVEL < value)
{
ret = pmic_set_keyled_intensity(LED_KEYPAD,LED_BRIGHTNESS_OFF);
}
else
{
ret = pmic_set_keyled_intensity(LED_KEYPAD, LED_BRIGHTNESS_LEVEL_U8680);
}
}
else if(machine_is_msm8255_u8667())
{
/* Set keypad led brightness level 16 for U8667 */
if(LED_BRIGHTNESS_OFF >= value || LED_PWM_LEVEL < value)
{
ret = pmic_set_keyled_intensity(LED_KEYPAD, LED_BRIGHTNESS_OFF);
}
else
{
ret = pmic_set_keyled_intensity(LED_KEYPAD, LED_BRIGHTNESS_LEVEL_U8667);
}
}
#endif
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
#else
int ret;
ret = pmic_set_led_intensity(LED_KEYPAD, value / MAX_KEYPAD_BL_LEVEL);
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
#endif
}
static int msm_pmic_led_probe(struct platform_device *pdev)
{
int ret = 0;
int i, j;
printk(KERN_NOTICE "PM_DEBUG_MXP:Enter msm_pmic_led_probe.\r\n");
#if defined (CONFIG_GPIO_10_11_CTRL_LED)
for (i = 0;i < 2; i++)
{
ret= gpio_tlmm_config(data_leds_gpio[i],GPIO_CFG_ENABLE);
if (ret)
{
printk(KERN_ERR "%s: gpio_tlmm_config(%#x)=%d\n", __func__, data_leds_gpio[i], ret);
return -EIO;
}
}
gpio_request(GPIO_RED_LIGHT_CTRL, "red_light_led_gpio");
gpio_request(GPIO_GREEN_LIGHT_CTRL, "green_light_led_gpio");
if((gpio_direction_output(GPIO_RED_LIGHT_CTRL, 0))<0) //turn off red
{
printk(KERN_ERR "gpio_direction_output: %d failed!\n", GPIO_RED_LIGHT_CTRL);
return -EIO;
}
if((gpio_direction_output(GPIO_GREEN_LIGHT_CTRL, 0))<0) //turn off green
{
printk(KERN_ERR "gpio_direction_output: %d failed!\n", GPIO_GREEN_LIGHT_CTRL);
return -EIO;
}
#elif defined (CONFIG_GPIO_34_49_CTRL_LED)
//For Pm8029 mpp init control,turn them off.
if((pmic_secure_mpp_config_i_sink(GPIO_RED_LIGHT_CTRL, 0, PM_MPP__I_SINK__SWITCH_DIS))<0)
{
printk(KERN_ERR "pmic_secure_mpp_config_i_sink: red Mpp=%d failed!\n", GPIO_RED_LIGHT_CTRL);
return -EIO;
}
else
{
//printk(KERN_ERR "pmic_secure_mpp_config_i_sink: red Mpp success!\n");
}
if((pmic_secure_mpp_config_i_sink(GPIO_GREEN_LIGHT_CTRL, 0, PM_MPP__I_SINK__SWITCH_DIS))<0)
{
printk(KERN_ERR "pmic_secure_mpp_config_i_sink: Green Mpp=%d failed!\n", GPIO_GREEN_LIGHT_CTRL);
return -EIO;
}
else
{
//printk(KERN_ERR "pmic_secure_mpp_config_i_sink: Green Mpp success!\n");
}
#elif defined(CONFIG_USE_PM_GPIO_CTRL_LED)
//waiting add about probe config
#else
//do nothing now.
#endif
STATUS_LED = kzalloc(sizeof(struct STATUS_LED_data), GFP_KERNEL);
if (STATUS_LED == NULL) {
printk(KERN_ERR "STATUS_LED_probe: no memory for device\n");
ret = -ENOMEM;
goto err_alloc_failed;
}
STATUS_LED->blink_led[0].led.name = "red";
STATUS_LED->blink_led[0].led.brightness_set = msm_pmic_bl_led_set;
STATUS_LED->blink_led[0].led.brightness = LED_OFF;
STATUS_LED->blink_led[0].blink_flag = 0;
STATUS_LED->blink_led[0].blink_on_time = 500;
STATUS_LED->blink_led[0].blink_off_time = 500;
STATUS_LED->blink_led[1].led.name = "green";
STATUS_LED->blink_led[1].led.brightness_set = msm_pmic_bl_led_set;
STATUS_LED->blink_led[1].led.brightness = LED_OFF;
STATUS_LED->blink_led[1].blink_flag = 0;
STATUS_LED->blink_led[1].blink_on_time = 500;
STATUS_LED->blink_led[1].blink_off_time = 500;
#ifdef CONFIG_HAS_EARLYSUSPEND
//printk(KERN_NOTICE "PM_DEBUG_MXP:Can register driver.\n");
STATUS_LED->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
STATUS_LED->early_suspend.suspend =msm_pmic_led_early_suspend;
STATUS_LED->early_suspend.resume = msm_pmic_led_late_resume;
register_early_suspend(&STATUS_LED->early_suspend);
#endif
spin_lock_init(&STATUS_LED->data_lock);
for (i = 0; i < 2; i++) { /* red, green */
ret = led_classdev_register(&pdev->dev, &STATUS_LED->blink_led[i].led);
if (ret) {
printk(KERN_ERR
"STATUS_LED: led_classdev_register failed\n");
goto err_led_classdev_register_failed;
}
}
for (i = 0; i < 2; i++) {
ret =
device_create_file(STATUS_LED->blink_led[i].led.dev, &dev_attr_blink);
if (ret) {
printk(KERN_ERR
"STATUS_LED: create dev_attr_blink failed\n");
goto err_out_attr_blink;
}
}
for (i = 0; i < 2; i++) {
ret =
device_create_file(STATUS_LED->blink_led[i].led.dev, &dev_attr_grppwm);
if (ret) {
printk(KERN_ERR
"STATUS_LED: create dev_attr_grppwm failed\n");
goto err_out_attr_grppwm;
}
}
for (i = 0; i < 2; i++) {
ret =
device_create_file(STATUS_LED->blink_led[i].led.dev, &dev_attr_grpfreq);
if (ret) {
printk(KERN_ERR
"STATUS_LED: create dev_attr_grpfreq failed\n");
goto err_out_attr_grpfreq;
}
}
dev_set_drvdata(&pdev->dev, STATUS_LED);
for (i = 0; i < 2; i++)
{
INIT_WORK(&STATUS_LED->blink_led[i].work_led_on, func[i*2]);
INIT_WORK(&STATUS_LED->blink_led[i].work_led_off, func[i*2+1]);
setup_timer(&STATUS_LED->blink_led[i].timer, pmic_leds_timer, (unsigned long)&STATUS_LED->blink_led[i]);
msm_pmic_bl_led_set(&STATUS_LED->blink_led[i].led, LED_OFF);
}
printk(KERN_NOTICE "PM_DEBUG_MXP:Exit msm_pmic_led_probe.\r\n");
return 0;
err_out_attr_grpfreq:
for (j = 0; j < i; j++)
device_remove_file(STATUS_LED->blink_led[i].led.dev, &dev_attr_blink);
i = 2;
err_out_attr_grppwm:
for (j = 0; j < i; j++)
device_remove_file(STATUS_LED->blink_led[i].led.dev, &dev_attr_blink);
i = 2;
err_out_attr_blink:
for (j = 0; j < i; j++)
device_remove_file(STATUS_LED->blink_led[i].led.dev, &dev_attr_blink);
i = 2;
err_led_classdev_register_failed:
for (j = 0; j < i; j++)
led_classdev_unregister(&STATUS_LED->blink_led[i].led);
err_alloc_failed:
kfree(STATUS_LED);
return ret;
}
