static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
#ifdef CONFIG_HUAWEI_LEDS_PMIC
int ret = 0;
if(machine_is_msm7x30_u8800())
{
if(disable_keypad_leds) value = 0;
ret = pmic_set_led_intensity(LED_KEYPAD, value / LED_FULL);
}
if(machine_is_msm7x30_u8820())
{
ret = pmic_set_mpp6_led_intensity(value / LED_FULL);
}
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 void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
printk("msm_keypad_bl_led_set:%d\n",value);
ret = pmic_set_led_intensity(LED_LCD, value / MAX_KEYPAD_BL_LEVEL);
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");
}
static void button_bl_leds_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
if( value < LEVEL_MAX )
ret = pmic_set_led_intensity(LED_LCD, value);
else
ret = pmic_set_led_intensity(LED_LCD, value / TUNED_MAX_BACKLIGHT_LEVEL);
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
}
static void keypad_led_resume( struct early_suspend *h)
{
atomic_set(&kp_suspend_flag, 0);
if (atomic_read(&button_flag))
{
pmic_set_led_intensity(LED_LCD, 1); /* turn on touchpad light when resume */
}
}
int keypad_led_set(unsigned char value)
{
int ret;
ret = pmic_set_led_intensity(LED_KEYPAD, value);
return ret;
}
void swift_turn_off_led(void)
{
int ret;
ret = pmic_set_led_intensity(LED_KEYPAD, 0);
if (ret)
printk(KERN_INFO "Can't turn of led\n");
}
static void swift_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
ret = pmic_set_led_intensity(LED_KEYPAD, value / MAX_BACKLIGHT_LEVEL);
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
#if defined (CONFIG_LGE_UNIFIED_LED)
ret = leds_pdata->msm_keypad_led_set(value / TUNED_MAX_KEYPAD_BL_LEVEL);
#else /* origin */
#ifdef CONFIG_MACH_MSM7X27_THUNDERA
/* [email protected]
* P505, use the android led interface values, 255,127,0
* LED current is controlled by arm9 AMSS with the given values.
*/
ret = pmic_set_led_intensity(LED_KEYPAD, value);
#else
ret = pmic_set_led_intensity(LED_KEYPAD, value / TUNED_MAX_KEYPAD_BL_LEVEL);
#endif /* end of CONFIG_MACH_MSM7X27_THUNDERA */
#endif
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
}
/*
* leds-msm-pmic.c - MSM PMIC LEDs driver.
*
* Copyright (c) 2009, Code Aurora Forum. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <mach/pmic.h>
#include <asm/mach-types.h>
#ifdef CONFIG_HUAWEI_APPS
#define MAX_KEYPAD_BL_LEVEL 64
#else
#define MAX_KEYPAD_BL_LEVEL 16
#endif
extern atomic_t kp_suspend_flag;
atomic_t button_flag = ATOMIC_INIT(0); /* "0" means turn 0ff */
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret = 0;
/* U8110 has no keypad backlight */
if( machine_is_msm7x25_u8110() )
{
/* there is nothing to do */
}
/* U8100 series uses LCD_DRV to control keypad backlight */
else if( machine_is_msm7x25_u8100() || machine_is_msm7x25_u8105() \
|| machine_is_msm7x25_u8107() || machine_is_msm7x25_u8109() )
{
/*set keypad backlight current to 10mA*/
ret = pmic_set_led_intensity(LED_LCD, value / LED_FULL);
}
else if ( machine_is_msm7x25_u8150() || machine_is_msm7x25_c8150() || machine_is_msm7x25_u8159() )
{
ret = pmic_set_led_intensity(LED_KEYPAD, 0); /* never turn on */
if ( !atomic_read(&kp_suspend_flag) )
{
ret = pmic_set_led_intensity(LED_LCD, value / LED_FULL);
}
if (LED_FULL == value) {
atomic_set(&button_flag, 1);
} else {
atomic_set(&button_flag, 0);
}
}
/* other series uses KEYPAD_DRV to control keypad backlight */
else
{
/*set keypad backlight current to 10mA*/
ret = pmic_set_led_intensity(LED_KEYPAD, value / LED_FULL);
}
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
#if defined (CONFIG_LGE_UNIFIED_LED)
ret = leds_pdata->msm_keypad_led_set(value / TUNED_MAX_KEYPAD_BL_LEVEL);
#else
#ifdef CONFIG_MACH_MSM7X27_THUNDERA
ret = pmic_set_led_intensity(LED_KEYPAD, value);
#else
#if defined(CONFIG_MACH_MSM7X27_SU310) || defined(CONFIG_MACH_MSM7X27_LU3100)
ret = pmic_set_led_intensity(LED_KEYPAD, value?1:0);
#else
ret = pmic_set_led_intensity(LED_KEYPAD, value / TUNED_MAX_KEYPAD_BL_LEVEL);
#endif
#endif
#endif
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
#if defined (CONFIG_LGE_UNIFIED_LED)
ret = leds_pdata->msm_keypad_led_set(value);
#else /* origin */
ret = pmic_set_led_intensity(LED_KEYPAD, value / TUNED_MAX_KEYPAD_BL_LEVEL);
#endif
if (ret)
dev_err(led_cdev->dev, "can't set keypad backlight\n");
}
static void msm_keypad_bl_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
int ret;
#ifdef CONFIG_MACH_PITTSBURGH
msm_keypad_bl_led_value_adjusted (&value);
#endif/* CONFIG_MACH_PITTSBURGH */
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");
}
//////////////////////////////////
// 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 int debug_set_led_intensity(char *buf, int size)
{
enum ledtype type;
int level;
int cnt;
cnt = sscanf(buf, "%u %d", &type, &level);
if (cnt < 2) {
printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt);
return -EINVAL;
}
if (pmic_set_led_intensity(type, level) < 0)
return -EFAULT;
return size;
}
static int hcit_ioctl(struct inode *ino, struct file *filp, unsigned int cmd,
unsigned long arg)
{
int err = 0;
switch (cmd) {
case HCIT_IOCTL_KEYLED_ON:
printk("[HCIT] HCIT_IOControl : IOCTL_GPIO_KEYLEDON \r\n");
pmic_set_led_intensity(LED_KEYPAD, PMIC_LED_LCD__LEVEL4);
break;
case HCIT_IOCTL_KEYLED_OFF:
printk("[HCIT] HCIT_IOControl : IOCTL_GPIO_KEYLEDOFF\r\n");
pmic_set_led_intensity(LED_KEYPAD, PMIC_LED_LCD__LEVEL0);
break;
case HCIT_IOCTL_VIB_ON:
{
int time_ms;
time_ms = *((int *)arg);
pmic_vib_mot_set_volt(VIBRATOR_MOTOR_ON_VOLT);
if (time_ms > 0) {
msleep(time_ms);
pmic_vib_mot_set_volt(VIBRATOR_MOTOR_OFF_VOLT);
}
}
break;
case HCIT_IOCTL_VIB_OFF:
pmic_vib_mot_set_volt(VIBRATOR_MOTOR_OFF_VOLT);
break;
case HCIT_IOCTL_LCD_BACKLIGHT_ON:
printk
("[HCIT] HCIT_IOControl : HCIT_IOCTL_LCD_BACKLIGHT_ON \r\n");
gpio_direction_output(29, 1);
break;
case HCIT_IOCTL_LCD_BACKLIGHT_OFF:
printk
("[HCIT] HCIT_IOControl : HCIT_IOCTL_LCD_BACKLIGHT_OFF \r\n");
gpio_direction_output(29, 0);
break;
case HCIT_IOCTL_GPIOLED_ON:
case HCIT_IOCTL_GPIOLED_OFF:
printk
("[HCIT] HCIT_IOControl : HCIT_IOCTL_GPIOLED_ON / OFF\r\n");
hcit_gpioled_ctl(arg);
break;
case HCIT_IOCTL_BLUETOOTH_ON:
err = bluetooth_power(1);
printk
("[HCIT] HCIT_IOControl : HCIT_IOCTL_BLUETOOTH_ON err<%d>\r\n",
err);
break;
case HCIT_IOCTL_BLUETOOTH_OFF:
err = bluetooth_power(0);
printk
("[HCIT] HCIT_IOControl : HCIT_IOCTL_BLUETOOTH_OFF err<%d>\r\n",
err);
break;
default:
printk("[HCIT] HCIT_IOControl : unknown cmd=%d\r\n", cmd);
break;
}
return 0;
}
/*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 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 keypad_led_suspend( struct early_suspend *h)
{
atomic_set(&kp_suspend_flag, 1);
pmic_set_led_intensity(LED_LCD, 0); /* turn off touchpad light when suspend */
}
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;
}
int backlight_pwm_gpio_config(void)
{
int rc;
struct pm8058_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,
};
/* U8800 use PM_GPIO25 as backlight's PWM,but U8820 use PM_GPIO26 */
if(machine_is_msm7x30_u8800() || machine_is_msm7x30_u8800_51() || machine_is_msm8255_u8800_pro())
{
rc = pm8058_gpio_config( 24, &backlight_drv);
}
else if(machine_is_msm7x30_u8820())
{
rc = pm8058_gpio_config( 25, &backlight_drv);
}
else
{
rc = -1;
}
if (rc)
{
pr_err("%s LCD backlight GPIO config failed\n", __func__);
return rc;
}
return 0;
}
#ifndef CONFIG_HUAWEI_LEDS_PMIC
void touchkey_setbacklight(int level)
{
if(machine_is_msm7x30_u8800() || machine_is_msm7x30_u8800_51() || machine_is_msm8255_u8800_pro())
{
pmic_set_led_intensity(LED_KEYPAD, level);
}
if(machine_is_msm7x30_u8820())
{
/*if the machine is U8820 use the mpp6 for touchkey backlight*/
pmic_set_mpp6_led_intensity(level);
}
}
#endif
void pwm_set_backlight (struct msm_fb_data_type * mfd)
{
int bl_level = mfd->bl_level;
/*config PM GPIO25 as PWM and request PWM*/
if(TRUE == first_set_bl)
{
backlight_pwm_gpio_config();
/* U8800 use PM_GPIO25 as backlight's PWM,but U8820 use PM_GPIO26 */
if(machine_is_msm7x30_u8800() || machine_is_msm7x30_u8800_51() || machine_is_msm8255_u8800_pro())
{
bl_pwm = pwm_request(PM_GPIO25_PWM_ID, "backlight");
}
else if(machine_is_msm7x30_u8820())
{
bl_pwm = pwm_request(PM_GPIO26_PWM_ID, "backlight");
}
else
{
bl_pwm = NULL;
}
if (NULL == bl_pwm || IS_ERR(bl_pwm))
{
pr_err("%s: pwm_request() failed\n", __func__);
bl_pwm = NULL;
}
first_set_bl = FALSE;
}
if (bl_pwm)
{
/* keep duty 10% < level < 90% */
if (bl_level)
{
bl_level = ((bl_level * PWM_LEVEL_ADJUST) / PWM_LEVEL + ADD_VALUE);
if (bl_level < BL_MIN_LEVEL)
{
bl_level = BL_MIN_LEVEL;
}
}
pwm_config(bl_pwm, PWM_DUTY_LEVEL*bl_level/NSEC_PER_USEC, PWM_PERIOD/NSEC_PER_USEC);
pwm_enable(bl_pwm);
}
#ifndef CONFIG_HUAWEI_LEDS_PMIC
touchkey_setbacklight(!!bl_level);
#endif
}
