static void haptic_work(struct work_struct *work)
{
struct max77843_haptic_data *hap_data
= container_of(work, struct max77843_haptic_data, work);
pr_info("[VIB] %s\n", __func__);
if (hap_data->timeout > 0) {
if (hap_data->running)
return;
max77843_haptic_i2c(hap_data, true);
pwm_config(hap_data->pwm, hap_data->pdata->duty,
hap_data->pdata->period);
pwm_enable(hap_data->pwm);
if (hap_data->pdata->motor_en)
hap_data->pdata->motor_en(true);
else {
int ret;
ret = regulator_enable(hap_data->regulator);
pr_info("regulator_enable returns %d\n", ret);
}
hap_data->running = true;
} else {
if (!hap_data->running)
return;
if (hap_data->pdata->motor_en)
hap_data->pdata->motor_en(false);
else
regulator_disable(hap_data->regulator);
pwm_disable(hap_data->pwm);
max77843_haptic_i2c(hap_data, false);
hap_data->running = false;
}
return;
}
static int mipi_lg_lcd_off(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
int ret;
printk("%s+\n", __func__);
mfd = platform_get_drvdata(pdev);
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
if (bl_lpm) {
ret = pwm_config(bl_lpm, 0, PWM_PERIOD_USEC);
if (ret) {
pr_err("pwm_config on lpm failed %d\n", ret);
}
pwm_disable(bl_lpm);
}
mdelay(210);
printk("%s, lg display off command+\n", __func__);
cmdreq_lg.cmds = lg_display_off_cmds;
cmdreq_lg.cmds_cnt = ARRAY_SIZE(lg_display_off_cmds);
cmdreq_lg.flags = CMD_REQ_COMMIT;
cmdreq_lg.rlen = 0;
cmdreq_lg.cb = NULL;
mipi_dsi_cmdlist_put(&cmdreq_lg);
printk("%s, lg display off command-\n", __func__);
mdelay(20);
printk("%s-\n", __func__);
return 0;
}
static int pwm_beeper_event(struct input_dev *input,
unsigned int type, unsigned int code, int value)
{
int ret = 0;
struct pwm_beeper *beeper = input_get_drvdata(input);
unsigned long period;
if (type != EV_SND || value < 0)
return -EINVAL;
switch (code) {
case SND_BELL:
value = value ? 1000 : 0;
break;
case SND_TONE:
break;
default:
return -EINVAL;
}
if (value == 0) {
//pwm_config(beeper->pwm, 0, 0);
pwm_disable(beeper->pwm);
xc2440_beeper_disable();
} else {
xc2440_beeper_enable();
period = HZ_TO_NANOSECONDS(value);
ret = pwm_config(beeper->pwm, period / 2, period);
if (ret)
return ret;
ret = pwm_enable(beeper->pwm);
if (ret)
return ret;
beeper->period = period;
}
return 0;
}
static void enable_lvds(struct display_info_t const *dev)
{
imx_iomux_v3_setup_multiple_pads(
display_pads,
ARRAY_SIZE(display_pads));
imx_iomux_v3_setup_multiple_pads(
backlight_pads,
ARRAY_SIZE(backlight_pads));
/* enable backlight PWM 3 */
if (pwm_init(2, 0, 0))
goto error;
/* duty cycle 500ns, period: 3000ns */
if (pwm_config(2, 500, 3000))
goto error;
if (pwm_enable(2))
goto error;
return;
error:
puts("error init pwm for backlight\n");
return;
}
static void lcdc_chimei_set_backlight(int level)
{
int ret;
if (bl_pwm) {
ret = pwm_config(bl_pwm, PWM_DUTY_LEVEL * level,
PWM_PERIOD_USEC);
if (ret) {
pr_err("%s: pwm_config on pwm failed %d\n",
__func__, ret);
return;
}
ret = pwm_enable(bl_pwm);
if (ret) {
pr_err("%s: pwm_enable on pwm failed %d\n",
__func__, ret);
return;
}
}
chimei_bl_level = level;
}
static void lvds_chimei_set_backlight(struct msm_fb_data_type *mfd)
{
int ret;
pr_debug("%s: back light level %d\n", __func__, mfd->bl_level);
if (bl_lpm) {
ret = pwm_config(bl_lpm, LVDS_CHIMEI_PWM_DUTY_LEVEL *
mfd->bl_level, LVDS_CHIMEI_PWM_PERIOD_USEC);
if (ret) {
pr_err("pwm_config on lpm failed %d\n", ret);
return;
}
if (mfd->bl_level) {
ret = pwm_enable(bl_lpm);
if (ret)
pr_err("pwm enable/disable on lpm failed"
"for bl %d\n", mfd->bl_level);
} else {
pwm_disable(bl_lpm);
}
}
}
void vibtonz_pwm(int nForce)
{
int pwm_period = 0, pwm_duty = 0;
if (g_hap_data == NULL) {
printk(KERN_ERR "[VIB] the motor is not ready!!!");
return ;
}
pwm_period = g_hap_data->pdata->period;
pwm_duty = pwm_period / 2 + ((pwm_period / 2 - 2) * nForce) / 127;
if (pwm_duty > g_hap_data->pdata->duty)
pwm_duty = g_hap_data->pdata->duty;
else if (pwm_period - pwm_duty > g_hap_data->pdata->duty)
pwm_duty = pwm_period - g_hap_data->pdata->duty;
/* add to avoid the glitch issue */
if (prev_duty != pwm_duty) {
prev_duty = pwm_duty;
pwm_config(g_hap_data->pwm, pwm_duty, pwm_period);
}
}
static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,
unsigned selector)
{
struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
unsigned int pwm_reg_period;
int dutycycle;
int ret;
pwm_reg_period = pwm_get_period(drvdata->pwm);
dutycycle = (pwm_reg_period *
drvdata->duty_cycle_table[selector].dutycycle) / 100;
ret = pwm_config(drvdata->pwm, dutycycle, pwm_reg_period);
if (ret) {
dev_err(&rdev->dev, "Failed to configure PWM\n");
return ret;
}
drvdata->state = selector;
return 0;
}
static int pm8xxx_vib_set_off(struct pm8xxx_vib_pwm *vib)
{
int rc = 0;
VIB_PWM_INFO("%s \n",__func__);
rc = pwm_config(vib->pwm_vib, period_us/2, period_us);
if (rc < 0) {
VIB_PWM_ERR("%s pwm config fail",__func__);
return -EINVAL;
}
rc = pwm_enable(vib->pwm_vib);
if (rc < 0) {
VIB_PWM_ERR("%s pwm enable fail",__func__);
return -EINVAL;
}
rc = gpio_direction_output(vib->ena_gpio, DISABLE_AMP);
if (rc < 0) {
VIB_PWM_ERR("%s disable amp fail",__func__);
return -EINVAL;
}
pwm_disable(vib->pwm_vib);
return rc;
}
void bd_display_run(char *cmd, int bl_duty, int bl_on)
{
static int display_init = 0;
if (cmd) {
run_command(cmd, 0);
lcd_draw_boot_logo(CONFIG_FB_ADDR, CFG_DISP_PRI_RESOL_WIDTH,
CFG_DISP_PRI_RESOL_HEIGHT, CFG_DISP_PRI_SCREEN_PIXEL_BYTE);
}
if (!display_init) {
bd_display();
pwm_init(CFG_LCD_PRI_PWM_CH, 0, 0);
display_init = 1;
}
pwm_config(CFG_LCD_PRI_PWM_CH,
TO_DUTY_NS(bl_duty, CFG_LCD_PRI_PWM_FREQ),
TO_PERIOD_NS(CFG_LCD_PRI_PWM_FREQ));
if (bl_on)
pwm_enable(CFG_LCD_PRI_PWM_CH);
}
static void lcdc_chimei_set_backlight(int level)
{
int ret;
int a[11] = {24,44,80,108,120,84,88,100,104,112,620};
int b[11] = {800,300,-1500,-3600,-4800,-300,-900,-3000,-3800,-5600,-132600};
int backlight;
/* As the pwm frquency set to 20kHZ, the level should be larger than 6, As the backlight require the level larger than 255 * 20% = 51 */
chimei_bl_level = level;
if(0 == level)
{
backlight = 0;
}
else
{
backlight = (a[level/25] * level + b[level/25])/100;
}
if (bl_pwm) {
ret = pwm_config(bl_pwm, backlight * PWM_PERIOD_USEC / PWM_LEVEL, PWM_PERIOD_USEC);
if (ret) {
pr_err("%s: pwm_config on pwm failed %d\n",
__func__, ret);
return;
}
ret = pwm_enable(bl_pwm);
if (ret) {
pr_err("%s: pwm_enable on pwm failed %d\n",
__func__, ret);
return;
}
}
}
/*
** Called to disable amp (disable output force)
*/
IMMVIBESPIAPI VibeStatus ImmVibeSPI_ForceOut_AmpDisable(VibeUInt8 nActuatorIndex)
{
#if 0
#error Please review the code between the #if and #endif
if (g_bAmpEnabled)
{
DbgOut((KERN_DEBUG "ImmVibeSPI_ForceOut_AmpDisable.\n"));
g_bAmpEnabled = false;
#if 0
mhn_gpio_set_level(GPIO_EN, GPIO_LEVEL_LOW);
mz_ops.bstat &= ~HN_BATTERY_MOTOR;
#endif
}
#endif
if (g_bAmpEnabled)
{
g_bAmpEnabled = false;
#if defined (CONFIG_TARGET_LOCALE_EUR) || defined (CONFIG_TARGET_LOCALE_HKTW) || defined (CONFIG_TARGET_LOCALE_HKTW_FET) || defined (CONFIG_TARGET_LOCALE_VZW) || defined (CONFIG_TARGET_LOCALE_USAGSM)
if(HWREV >= 0xf)
#elif defined (CONFIG_TARGET_LOCALE_KOR)
if(HWREV >= 0xe)
#else
if(HWREV >= 0xff)
#endif
{
pwm_config(Immvib_pwm, 0, g_PWM_duty_max/2);
pwm_disable(Immvib_pwm);
gpio_set_value(VIB_EN, GPIO_LEVEL_LOW);
}
max8998_ldo_disable_direct(MAX8998_LDO16);
}
return VIBE_S_SUCCESS;
}
static void enable_display_power(void)
{
imx_iomux_v3_setup_multiple_pads(backlight_pads,
ARRAY_SIZE(backlight_pads));
/* backlight enable */
gpio_direction_output(IMX_GPIO_NR(6, 31), 1);
/* LCD power enable */
gpio_direction_output(IMX_GPIO_NR(6, 15), 1);
/* enable backlight PWM 1 */
if (pwm_init(0, 0, 0))
goto error;
/* duty cycle 500ns, period: 3000ns */
if (pwm_config(0, 50000, 300000))
goto error;
if (pwm_enable(0))
goto error;
return;
error:
puts("error init pwm for backlight\n");
return;
}
/**
* Set Backlight level.
*
* @param pwm
* @param level
*
* @return int
*/
static int mipi_d2l_set_backlight_level(struct pwm_device *pwm, int level)
{
int ret = 0;
pr_debug("%s: level=%d.\n", __func__, level);
#if defined(CONFIG_FB_MSM_MIPI_BOEOT_TFT_VIDEO_WSVGA_PT_PANEL) \
|| defined(CONFIG_FB_MSM_MIPI_SAMSUNG_TFT_VIDEO_WXGA_PT_PANEL)
if ((pwm == NULL) || (level > BRIGHTNESS_MAX) || (level < 0)) {
pr_err("%s.pwm=NULL.\n", __func__);
return -EINVAL;
}
level = scale_pwm_dutycycle(level);
#else
if ((pwm == NULL) || (level > PWM_LEVEL) || (level < 0)) {
pr_err("%s.pwm=NULL.\n", __func__);
return -EINVAL;
}
#endif
ret = pwm_config(pwm, PWM_DUTY_LEVEL * level, PWM_PERIOD_USEC);
if (ret) {
pr_err("%s: pwm_config() failed err=%d.\n", __func__, ret);
return ret;
}
ret = pwm_enable(pwm);
if (ret) {
pr_err("%s: pwm_enable() failed err=%d\n",
__func__, ret);
return ret;
}
return 0;
}
static void pm8058_pwm_led_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct pm8058_led_data *ldata;
int enable = 0;
/* struct pwm_device* pwm_led; */
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
pwm_disable(ldata->pwm_led);
brightness = (brightness > LED_FULL) ? LED_FULL : brightness;
brightness = (brightness < LED_OFF) ? LED_OFF : brightness;
printk(KERN_INFO "%s: bank %d brightness %d +\n", __func__,
ldata->bank, brightness);
enable = (brightness) ? 1 : 0;
if (strcmp(ldata->ldev.name, "charming-led") == 0)
charming_led_enable(enable);
if (brightness) {
pwm_config(ldata->pwm_led, 64000, 64000);
#if 0
pwm_conf.pwm_size = ldata->pwm_size;
pwm_conf.clk = ldata->clk;
pwm_conf.pre_div = ldata->pre_div;
pwm_conf.pre_div_exp = ldata->pre_div_exp;
pwm_conf.pwm_value = ldata->pwm_value;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
#endif
pwm_enable(ldata->pwm_led);
}
printk(KERN_INFO "%s: bank %d brightness %d -\n", __func__,
ldata->bank, brightness);
}
static ssize_t pwm_test_store_duty(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int rc;
struct pwm_test *pwm_test = dev_get_drvdata(dev);
int duty;
rc = kstrtoint(buf, 0, &duty);
if (rc)
return rc;
if (duty < 0)
return -EINVAL;
rc = pwm_config(pwm_test->pwm, duty, pwm_test->period);
if (rc) {
dev_err(dev, "pwm_config() failed\n");
return rc;
}
pwm_test->duty = duty;
return count;
}
static int isa1000_vib_set(struct isa1000_vib *vib, int on)
{
int rc;
if (on) {
rc = pwm_config(pwm,
(pwm_period_ns * pwm_duty) / 100,
pwm_period_ns);
if (rc < 0){
printk( "Unable to config pwm%d\n",rc);
}
rc = pwm_enable(pwm);
if (rc < 0){
printk("Unable to enable pwm\n");
}
gpio_set_value_cansleep(GPIO_ISA1000_EN, 1);
} else {
gpio_set_value_cansleep(GPIO_ISA1000_EN, 0);
pwm_disable(pwm);
}
return rc;
}
void vibtonz_en(bool en)
{
int ret;
if (g_hap_data == NULL) {
printk(KERN_ERR "[VIB] the motor is not ready!!!");
return ;
}
if (en) {
if (g_hap_data->running)
return;
max77888_haptic_i2c(g_hap_data, true);
pwm_config(g_hap_data->pwm, prev_duty, g_hap_data->pdata->period);
pwm_enable(g_hap_data->pwm);
if (g_hap_data->pdata->motor_en)
g_hap_data->pdata->motor_en(true);
else
ret = regulator_enable(g_hap_data->regulator);
g_hap_data->running = true;
} else {
if (!g_hap_data->running)
return;
if (g_hap_data->pdata->motor_en)
g_hap_data->pdata->motor_en(false);
else
regulator_disable(g_hap_data->regulator);
pwm_disable(g_hap_data->pwm);
max77888_haptic_i2c(g_hap_data, false);
g_hap_data->running = false;
}
}
static void set_pwm(unsigned int percent)
{
unsigned long duty;
if(percent > 100)
{
duty = PERIOD;
gDuty = 100;
}
else if(percent < 0)
{
duty = 0;
gDuty = 0;
}
else
{
duty = (PERIOD * percent)/100;
gDuty = percent;
}
pr_info("Duty set to : %ld\n", duty);
if(duty != gDuty)
{
pwm_config(pwm_dev, duty, PERIOD);
}
}
static ssize_t pm8058_led_blink_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev;
struct pm8058_led_data *ldata;
int id, mode;
int val;
int enable = 0;
#ifdef CONFIG_HTC_HEADSET_MISC
int *pduties;
#endif
/*struct timespec ts1, ts2;*/
val = -1;
sscanf(buf, "%u", &val);
if (val < 0 || val > 255)
return -EINVAL;
led_cdev = (struct led_classdev *) dev_get_drvdata(dev);
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
id = bank_to_id(ldata->bank);
mode = (id == PM_PWM_LED_KPD) ? PM_PWM_CONF_PWM1 :
PM_PWM_CONF_PWM1 + (ldata->bank - 4);
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id, mode,
ldata->out_current);
LED_INFO_LOG("%s: bank %d blink %d\n", __func__, ldata->bank, val);
enable = (val > 0) ? 1 : 0;
if (strcmp(ldata->ldev.name, "charming-led") == 0)
charming_led_enable(enable);
switch (val) {
case -1: /* stop flashing */
pwm_disable(ldata->pwm_led);
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id, mode, 0);
break;
case 0:
pwm_disable(ldata->pwm_led);
if (led_cdev->brightness) {
pwm_config(ldata->pwm_led, 6400 * pwm_coefficient / 100, 6400);
pwm_enable(ldata->pwm_led);
} else {
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id,
mode, 0);
}
break;
case 1:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 64000, 2000000);
pwm_enable(ldata->pwm_led);
break;
case 2:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(310));
break;
case 3:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(1000));
break;
case 4:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 1000000, 2000000);
#if 0
pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_1KHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_2;
pwm_conf.pre_div_exp = 1;
pwm_conf.pwm_value = 512/2;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
#endif
pwm_enable(ldata->pwm_led);
break;
case 5:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 100000, 200000);
pwm_enable(ldata->pwm_led);
break;
#ifdef CONFIG_HTC_HEADSET_MISC
case 6:
pm8058_pwm_config_led(ldata->pwm_led, id, mode,
ldata->out_current);
pduties = &duties[ldata->start_index];
pm8058_pwm_lut_config(ldata->pwm_led, ldata->period_us,
pduties, ldata->duty_time_ms,
ldata->start_index, ldata->duites_size,
0, 0, ldata->lut_flag);
pm8058_pwm_lut_enable(ldata->pwm_led, 0);
pm8058_pwm_lut_enable(ldata->pwm_led, 1);
break;
case 7:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 64000, 4000000);
pwm_enable(ldata->pwm_led);
break;
#endif
default:
LED_ERR_LOG(KERN_INFO "%s: bank %d not support blink %d\n", __func__, ldata->bank, val);
return -EINVAL;
}
return count;
}
/*
* Setup all sub sys of unicorn
*/
static int unicorn_setup()
{
int ret = 0;
if (bbp_board_type == BOARD_BBP1) {
printf("Board is FastBot BBP 1\n");
ret = analog_config(analog_config_bbp1, NR_ITEMS(analog_config_bbp1));
if (ret < 0) {
printf("analog_config failed\n");
goto out;
}
ret = temp_config(temp_config_data_bbp1, NR_ITEMS(temp_config_data_bbp1));
if (ret < 0) {
printf("temp_config failed\n");
goto out;
}
ret = pwm_config(pwm_config_bbp1, NR_ITEMS(pwm_config_bbp1));
if (ret < 0) {
printf("pwm_config failed\n");
goto out;
}
ret = fan_config(fan_config_bbp1, NR_ITEMS(fan_config_bbp1));
if (ret < 0) {
printf("fan_config failed\n");
goto out;
}
ret = heater_config(heater_config_data_bbp, NR_ITEMS(heater_config_data_bbp));
if (ret < 0) {
printf("heater_config failed\n");
goto out;
}
ret = stepper_config(stepper_config_bbp1, NR_ITEMS(stepper_config_bbp1));
if (ret < 0) {
printf("stepper_config failed\n");
goto out;
}
} else if (bbp_board_type == BOARD_BBP1S) {
printf("Board is FastBot BBP 1s\n");
ret = analog_config(analog_config_bbp1s, NR_ITEMS(analog_config_bbp1s));
if (ret < 0) {
printf("analog_config failed\n");
goto out;
}
ret = temp_config(temp_config_data_bbp1s, NR_ITEMS(temp_config_data_bbp1s));
if (ret < 0) {
printf("temp_config failed\n");
goto out;
}
ret = pwm_config(pwm_config_bbp1s, NR_ITEMS(pwm_config_bbp1s));
if (ret < 0) {
printf("pwm_config failed\n");
goto out;
}
ret = fan_config(fan_config_bbp1s, NR_ITEMS(fan_config_bbp1s));
if (ret < 0) {
printf("fan_config failed\n");
goto out;
}
ret = heater_config(heater_config_data_bbp1s, NR_ITEMS(heater_config_data_bbp1s));
if (ret < 0) {
printf("heater_config failed\n");
goto out;
}
#ifdef SERVO
if (bbp_board_type == BOARD_BBP1S) {
ret = servo_config(servo_config_data, NR_ITEMS(servo_config_data));
if (ret < 0) {
printf("servo_config failed\n");
goto out;
}
}
#endif
ret = stepper_config(stepper_config_bbp1s, NR_ITEMS(stepper_config_bbp1s));
if (ret < 0) {
printf("stepper_config failed\n");
goto out;
}
} else {
printf("Not supported board!\n");
}
out:
return ret;
}
static int __devinit vibrator_probe(struct platform_device *pdev)
{
struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
struct max8997_platform_data *max8997_pdata
= dev_get_platdata(max8997->dev);
struct max8997_motor_data *pdata = max8997_pdata->motor;
struct vibrator_drvdata *ddata;
int error = 0;
ddata = kzalloc(sizeof(struct vibrator_drvdata), GFP_KERNEL);
if (NULL == ddata) {
pr_err("[VIB] Failed to alloc memory\n");
error = -ENOMEM;
goto err_free_mem;
}
if (pdata->init_hw)
pdata->init_hw();
else {
ddata->regulator = regulator_get(NULL, "vmotor");
if (IS_ERR(ddata->regulator)) {
pr_err("[VIB] Failed to get vmoter regulator.\n");
error = -EFAULT;
goto err_regulator_get;
}
}
ddata->pdata = pdata;
ddata->dev.name = "vibrator";
ddata->dev.get_time = vibrator_get_time;
ddata->dev.enable = vibrator_enable;
ddata->client = max8997->hmotor;
platform_set_drvdata(pdev, ddata);
hrtimer_init(&ddata->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ddata->timer.function = vibrator_timer_func;
INIT_WORK(&ddata->work, vibrator_work);
spin_lock_init(&ddata->lock);
ddata->pwm = pwm_request(pdata->pwm_id, "vibrator");
if (IS_ERR(ddata->pwm)) {
pr_err("[VIB] Failed to request pwm.\n");
error = -EFAULT;
goto err_pwm_request;
}
pwm_config(ddata->pwm,
ddata->pdata->period/2, ddata->pdata->period);
vibetonz_clk_on(&pdev->dev, true);
error = timed_output_dev_register(&ddata->dev);
if (error < 0) {
pr_err("[VIB] Failed to register timed_output : %d\n", error);
error = -EFAULT;
goto err_timed_output_register;
}
/* User controllable pwm level */
error = device_create_file(ddata->dev.dev, &dev_attr_pwm_value);
if (error < 0) {
pr_err("[VIB] create sysfs fail: pwm_value\n");
}
#ifdef CONFIG_VIBETONZ
g_data = ddata;
pwm_duty_max = g_data->pdata->duty;
pwm_duty_min = pwm_duty_max/2;
pwm_duty = (pwm_duty_min + pwm_duty_max)/2;
#endif
return 0;
err_timed_output_register:
timed_output_dev_unregister(&ddata->dev);
err_regulator_get:
regulator_put(ddata->regulator);
err_pwm_request:
pwm_free(ddata->pwm);
err_free_mem:
kfree(ddata);
return error;
}
extern void pm8058_drvx_led_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct pm8058_led_data *ldata;
int *pduties;
int id, mode;
int lut_flag;
int milliamps;
int enable = 0;
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
pwm_disable(ldata->pwm_led);
cancel_delayed_work_sync(&ldata->led_delayed_work);
id = bank_to_id(ldata->bank);
mode = (id == PM_PWM_LED_KPD) ? PM_PWM_CONF_PWM1 :
PM_PWM_CONF_PWM1 + (ldata->bank - 4);
brightness = (brightness > LED_FULL) ? LED_FULL : brightness;
brightness = (brightness < LED_OFF) ? LED_OFF : brightness;
LED_INFO_LOG("%s: bank %d brightness %d +\n", __func__,
ldata->bank, brightness);
enable = (brightness) ? 1 : 0;
if (strcmp(ldata->ldev.name, "charming-led") == 0)
charming_led_enable(enable);
lut_flag = ldata->lut_flag & ~(PM_PWM_LUT_LOOP | PM_PWM_LUT_REVERSE);
virtual_key_state = enable;
if (flag_hold_virtual_key == 1) {
LED_INFO_LOG("%s, Return control by button_backlight flash \n", __func__);
return;
}
if (brightness) {
milliamps = (ldata->flags & PM8058_LED_DYNAMIC_BRIGHTNESS_EN) ?
ldata->out_current * brightness / LED_FULL :
ldata->out_current;
pm8058_pwm_config_led(ldata->pwm_led, id, mode, milliamps);
if (ldata->flags & PM8058_LED_LTU_EN) {
pduties = &duty_array[ldata->start_index];
pm8058_pwm_lut_config(ldata->pwm_led,
ldata->period_us,
pduties,
ldata->duty_time_ms,
ldata->start_index,
ldata->duites_size,
0, 0,
lut_flag);
pm8058_pwm_lut_enable(ldata->pwm_led, 0);
pm8058_pwm_lut_enable(ldata->pwm_led, 1);
} else {
pwm_config(ldata->pwm_led, 64000, 64000);
pwm_enable(ldata->pwm_led);
}
} else {
if (ldata->flags & PM8058_LED_LTU_EN) {
wake_lock_timeout(&pmic_led_wake_lock,HZ*2);
pduties = &duty_array[ldata->start_index +
ldata->duites_size];
pm8058_pwm_lut_config(ldata->pwm_led,
ldata->period_us,
pduties,
ldata->duty_time_ms,
ldata->start_index +
ldata->duites_size,
ldata->duites_size,
0, 0,
lut_flag);
pm8058_pwm_lut_enable(ldata->pwm_led, 1);
queue_delayed_work(g_led_work_queue,
&ldata->led_delayed_work,
msecs_to_jiffies(ldata->duty_time_ms * ldata->duites_size));
LED_INFO_LOG("%s: bank %d fade out brightness %d -\n", __func__,
ldata->bank, brightness);
return;
} else
pwm_disable(ldata->pwm_led);
pm8058_pwm_config_led(ldata->pwm_led, id, mode, 0);
}
LED_INFO_LOG("%s: bank %d brightness %d -\n", __func__, ldata->bank, brightness);
}
static void rx1950_lcd_power(int enable)
{
int i;
static int enabled;
if (enabled == enable)
return;
if (!enable) {
/* GPC11-GPC15->OUTPUT */
for (i = 11; i < 16; i++)
gpio_direction_output(S3C2410_GPC(i), 1);
/* Wait a bit here... */
mdelay(100);
/* GPD2-GPD7->OUTPUT */
/* GPD11-GPD15->OUTPUT */
/* GPD2-GPD7->1, GPD11-GPD15->1 */
for (i = 2; i < 8; i++)
gpio_direction_output(S3C2410_GPD(i), 1);
for (i = 11; i < 16; i++)
gpio_direction_output(S3C2410_GPD(i), 1);
/* Wait a bit here...*/
mdelay(100);
/* GPB0->OUTPUT, GPB0->0 */
gpio_direction_output(S3C2410_GPB(0), 0);
/* GPC1-GPC4->OUTPUT, GPC1-4->0 */
for (i = 1; i < 5; i++)
gpio_direction_output(S3C2410_GPC(i), 0);
/* GPC15-GPC11->0 */
for (i = 11; i < 16; i++)
gpio_direction_output(S3C2410_GPC(i), 0);
/* GPD15-GPD11->0, GPD2->GPD7->0 */
for (i = 11; i < 16; i++)
gpio_direction_output(S3C2410_GPD(i), 0);
for (i = 2; i < 8; i++)
gpio_direction_output(S3C2410_GPD(i), 0);
/* GPC6->0, GPC7->0, GPC5->0 */
gpio_direction_output(S3C2410_GPC(6), 0);
gpio_direction_output(S3C2410_GPC(7), 0);
gpio_direction_output(S3C2410_GPC(5), 0);
/* GPB1->OUTPUT, GPB1->0 */
gpio_direction_output(S3C2410_GPB(1), 0);
pwm_config(lcd_pwm, 0, LCD_PWM_PERIOD);
pwm_disable(lcd_pwm);
/* GPC0->0, GPC10->0 */
gpio_direction_output(S3C2410_GPC(0), 0);
gpio_direction_output(S3C2410_GPC(10), 0);
} else {
pwm_config(lcd_pwm, LCD_PWM_DUTY, LCD_PWM_PERIOD);
pwm_enable(lcd_pwm);
gpio_direction_output(S3C2410_GPC(0), 1);
gpio_direction_output(S3C2410_GPC(5), 1);
s3c_gpio_cfgpin(S3C2410_GPB(1), S3C2410_GPB1_TOUT1);
gpio_direction_output(S3C2410_GPC(7), 1);
for (i = 1; i < 5; i++)
s3c_gpio_cfgpin(S3C2410_GPC(i), S3C_GPIO_SFN(2));
for (i = 11; i < 16; i++)
s3c_gpio_cfgpin(S3C2410_GPC(i), S3C_GPIO_SFN(2));
for (i = 2; i < 8; i++)
s3c_gpio_cfgpin(S3C2410_GPD(i), S3C_GPIO_SFN(2));
for (i = 11; i < 16; i++)
s3c_gpio_cfgpin(S3C2410_GPD(i), S3C_GPIO_SFN(2));
gpio_direction_output(S3C2410_GPC(10), 1);
gpio_direction_output(S3C2410_GPC(6), 1);
}
enabled = enable;
}
static void pm8xxx_led_current_set_flagged(struct led_classdev *led_cdev, enum led_brightness brightness, int blink)
{
struct pm8xxx_led_data *led = container_of(led_cdev, struct pm8xxx_led_data, cdev);
int rc, offset;
u8 level;
int *pduties;
LED_INFO("%s, bank:%d, brightness:%d\n", __func__, led->bank, brightness);
cancel_delayed_work_sync(&led->fade_delayed_work);
virtual_key_state = brightness;
if (flag_hold_virtual_key == 1) {
LED_INFO("%s, key control \n", __func__);
return;
}
if(brightness) {
level = (led->out_current << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(led->id);
led->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
led->reg |= level;
rc = pm8xxx_writeb(led->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), led->reg);
if (rc)
LED_ERR("%s can't set (%d) led value rc=%d\n", __func__, led->id, rc);
if (led->function_flags & LED_BRETH_FUNCTION) {
if (blink == 0) {
buttons_led_is_on = 1;
// no blink needed
pduties = &dutys_array[0];
pm8xxx_pwm_lut_config(led->pwm_led,
led->period_us,
pduties,
led->duty_time_ms,
led->start_index,
led->duites_size,
0, 0,
led->lut_flag);
} else {
pduties = &dutys_array[0];
// LUT_LOOP for blinking
pm8xxx_pwm_lut_config(led->pwm_led,
led->period_us,
pduties,
led->duty_time_ms, // slower, 2x
led->start_index,
led->duites_size * 8, // 16 duty entries -> original size * 2, + 6 * 8 zeroes for pause
0, 0,
PM_PWM_LUT_LOOP | PM_PWM_LUT_PAUSE_HI_EN);
}
pm8xxx_pwm_lut_enable(led->pwm_led, 0);
pm8xxx_pwm_lut_enable(led->pwm_led, 1);
} else {
pwm_config(led->pwm_led, 6400 * led->pwm_coefficient / 100, 6400);
pwm_enable(led->pwm_led);
}
} else {
if (led->function_flags & LED_BRETH_FUNCTION) {
buttons_led_is_on = 0;
wake_lock_timeout(&pmic_led_wake_lock, HZ*2);
pduties = &dutys_array[8];
pm8xxx_pwm_lut_config(led->pwm_led,
led->period_us,
pduties,
led->duty_time_ms,
led->start_index,
led->duites_size,
0, 0,
led->lut_flag);
pm8xxx_pwm_lut_enable(led->pwm_led, 0);
pm8xxx_pwm_lut_enable(led->pwm_led, 1);
queue_delayed_work(g_led_work_queue,
&led->fade_delayed_work,
msecs_to_jiffies(led->duty_time_ms*led->duites_size));
} else {
pwm_disable(led->pwm_led);
level = (0 << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(led->id);
led->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
led->reg |= level;
rc = pm8xxx_writeb(led->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), led->reg);
if (rc)
LED_ERR("%s can't set (%d) led value rc=%d\n", __func__, led->id, rc);
}
}
}
int msm_camera_flash_led(
struct msm_camera_sensor_flash_external *external,
unsigned led_state)
{
#ifdef CONFIG_IMX175
#if defined(CONFIG_MACH_MELIUS)
int i = 0;
#endif
int rc = 0;
if(Torch_On == true) {
cam_err("[Assistive Light On!!\n");
return 0;
}
#if defined(CONFIG_MACH_MELIUS)
/* FLASH IC : KTD2692 */
cam_err("[led_state::%d]\n", led_state);
switch (led_state) {
case MSM_CAMERA_LED_INIT:
cam_err("[MSM_CAMERA_LED_INIT]\n");
#if defined(CONFIG_MACH_CRATER_CHN_CTC) || defined(CONFIG_MACH_MELIUS_VZW) || defined(CONFIG_MACH_MELIUS_SPR) || defined(CONFIG_MACH_MELIUS_USC)
if (system_rev < 0X01) {
#else
if (system_rev < 0x07) {
#endif
set_gpio_ENF(external, false);
} else {
/* Disable Cutoff Low voltage */
KTD2692_ctrl_cmd(external, LVP_SETTING | 0x00);
/*D2692_ctrl_cmd(external, MODE_CONTROL | 0x00);*/
}
break;
case MSM_CAMERA_LED_RELEASE:
cam_err("[MSM_CAMERA_LED_RELEASE]\n");
gpio_set_value_cansleep(external->led_flash_en, 0);
break;
case MSM_CAMERA_LED_OFF:
cam_err("[MSM_CAMERA_LED_OFF]\n");
#if defined(CONFIG_MACH_CRATER_CHN_CTC) || defined(CONFIG_MACH_MELIUS_VZW) || defined(CONFIG_MACH_MELIUS_SPR) || defined(CONFIG_MACH_MELIUS_USC)
if (system_rev < 0X01) {
#else
if (system_rev < 0x07) {
#endif
set_gpio_ENF(external, false);
} else {
KTD2692_ctrl_cmd(external, MODE_CONTROL | 0x00);
}
break;
case MSM_CAMERA_LED_LOW:
/* Movie Current Setting : 0x64 (5/16) */
cam_err("[MSM_CAMERA_LED_LOW]\n");
#if defined(CONFIG_MACH_CRATER_CHN_CTC) || defined(CONFIG_MACH_MELIUS_VZW) || defined(CONFIG_MACH_MELIUS_SPR) || defined(CONFIG_MACH_MELIUS_USC)
if (system_rev < 0X01) {
#else
if (system_rev < 0x07) {
#endif
for (i = 2; i > 0; i--) {
set_gpio_ENF(external, false);
ndelay(300);
set_gpio_ENF(external, true);
ndelay(300);
}
} else {
/* Disable Cutoff Low voltage */
KTD2692_ctrl_cmd(external, LVP_SETTING | 0x00);
/*KTD2692_ctrl_cmd(external, MOVIE_CURRENT | 0x04);*/
KTD2692_ctrl_cmd(external, MODE_CONTROL | 0x01);
}
break;
case MSM_CAMERA_LED_HIGH:
cam_err("[MSM_CAMERA_LED_HIGH]\n");
#if defined(CONFIG_MACH_CRATER_CHN_CTC) || defined(CONFIG_MACH_MELIUS_VZW) || defined(CONFIG_MACH_MELIUS_SPR) || defined(CONFIG_MACH_MELIUS_USC)
if (system_rev < 0X01) {
#else
if (system_rev < 0x07) {
#endif
for (i = 16; i > 0; i--) {
set_gpio_ENF(external, false);
ndelay(300);
set_gpio_ENF(external, true);
ndelay(300);
}
} else {
/* Disable Cutoff Low voltage */
KTD2692_ctrl_cmd(external, LVP_SETTING | 0x00);
/*KTD2692_ctrl_cmd(external, FLASH_CURRENT | 0x0F);*/
KTD2692_ctrl_cmd(external, MODE_CONTROL | 0x02);
}
break;
default:
cam_err("[default]\n");
rc = -EFAULT;
break;
}
#elif defined (CONFIG_MACH_SERRANO) || defined (CONFIG_MACH_CRATER) || defined (CONFIG_MACH_BAFFIN)
/* FLASH IC : MIC2871YMK*/
cam_err("[led_state::%d]\n", led_state);
switch (led_state) {
case MSM_CAMERA_LED_INIT:
cam_err("[MSM_CAMERA_LED_INIT][MIC2871YMK]\n");
gpio_tlmm_config(GPIO_CFG(GPIO_MSM_FLASH_CNTL_EN, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
gpio_tlmm_config(GPIO_CFG(GPIO_MSM_FLASH_NOW, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
break;
case MSM_CAMERA_LED_RELEASE:
MIC2871YMK_set_flash_flash(0);
cam_err("[MSM_CAMERA_LED_RELEASE][MIC2871YMK]\n");
break;
case MSM_CAMERA_LED_OFF:
cam_err("[MSM_CAMERA_LED_OFF][MIC2871YMK]\n");
MIC2871YMK_set_flash_flash(0);
break;
case MSM_CAMERA_LED_LOW:
cam_err("[MSM_CAMERA_LED_LOW][MIC2871YMK]\n");
MIC2871YMK_set_flash_movie(1);
break;
case MSM_CAMERA_LED_HIGH:
cam_err("[MSM_CAMERA_LED_HIGH][MIC2871YMK]\n");
MIC2871YMK_set_flash_flash(1);
break;
default:
cam_err("[default][MIC2871YMK]\n");
rc = -EFAULT;
break;
}
#elif defined (CONFIG_MACH_KS02)
printk("[led_state::%d]\n", led_state);
switch (led_state) {
case MSM_CAMERA_LED_INIT:
cam_err("[MSM_CAMERA_LED_INIT]\n");
break;
case MSM_CAMERA_LED_RELEASE:
cam_err("[MSM_CAMERA_LED_RELEASE]\n");
gpio_set_value_cansleep(GPIO_CAM_FLASH_EN, 0);
gpio_set_value_cansleep(GPIO_CAM_FLASH_SET, 0);
break;
case MSM_CAMERA_LED_OFF:
cam_err("[MSM_CAMERA_LED_OFF]\n");
gpio_set_value_cansleep(GPIO_CAM_FLASH_EN, 0);
gpio_set_value_cansleep(GPIO_CAM_FLASH_SET, 0);
break;
case MSM_CAMERA_LED_LOW:
cam_err("[MSM_CAMERA_LED_LOW]\n");
gpio_set_value_cansleep(GPIO_CAM_FLASH_SET, 1);
break;
case MSM_CAMERA_LED_HIGH:
cam_err("[MSM_CAMERA_LED_HIGH]\n");
gpio_set_value_cansleep(GPIO_CAM_FLASH_EN, 1);
break;
default:
cam_err("[default]\n");
rc = -EFAULT;
break;
}
#endif
return rc;
#elif defined (CONFIG_S5K4ECGX)
#if defined (CONFIG_MACH_CANE) || defined (CONFIG_MACH_LOGANRE)
int rc = 0;
printk("[led_state::%d]\n", led_state);
switch (led_state) {
case MSM_CAMERA_LED_INIT:
cam_err("[MSM_CAMERA_LED_INIT][RT8547]\n");
gpio_tlmm_config(GPIO_CFG(GPIO_CAM_FLASH_SOURCE_EN, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
gpio_tlmm_config(GPIO_CFG(GPIO_CAM_FLASH_SET, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
gpio_tlmm_config(GPIO_CFG(GPIO_CAM_FLASH_EN, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
/* LVP */
//RT8547_ctrl_cmd(external, 0x00);
break;
case MSM_CAMERA_LED_RELEASE:
cam_err("[MSM_CAMERA_LED_RELEASE]\n");
break;
case MSM_CAMERA_LED_OFF:
printk("[Torch flash]OFF\n");
#if defined (CONFIG_LEDS_RT8547)
rt8547_set_led_off();
#endif
break;
case MSM_CAMERA_LED_LOW:
printk("[Torch flash]ON\n");
#if defined (CONFIG_LEDS_RT8547)
rt8547_set_led_low();
#endif
break;
case MSM_CAMERA_LED_HIGH:
printk("[Torch flash]ON\n");
#if defined (CONFIG_LEDS_RT8547)
rt8547_set_led_high();
#endif
break;
default:
rc = -EFAULT;
break;
}
#endif
return rc;
#else
int rc = 0;
CDBG("msm_camera_flash_led: %d\n", led_state);
switch (led_state) {
case MSM_CAMERA_LED_INIT:
rc = gpio_request(external->led_en, "sgm3141");
CDBG("MSM_CAMERA_LED_INIT: gpio_req: %d %d\n",
external->led_en, rc);
if (!rc)
gpio_direction_output(external->led_en, 0);
else
return 0;
rc = gpio_request(external->led_flash_en, "sgm3141");
CDBG("MSM_CAMERA_LED_INIT: gpio_req: %d %d\n",
external->led_flash_en, rc);
if (!rc)
gpio_direction_output(external->led_flash_en, 0);
break;
case MSM_CAMERA_LED_RELEASE:
CDBG("MSM_CAMERA_LED_RELEASE\n");
gpio_set_value_cansleep(external->led_en, 0);
gpio_free(external->led_en);
gpio_set_value_cansleep(external->led_flash_en, 0);
gpio_free(external->led_flash_en);
break;
case MSM_CAMERA_LED_OFF:
CDBG("MSM_CAMERA_LED_OFF\n");
gpio_set_value_cansleep(external->led_en, 0);
gpio_set_value_cansleep(external->led_flash_en, 0);
break;
case MSM_CAMERA_LED_LOW:
CDBG("MSM_CAMERA_LED_LOW\n");
gpio_set_value_cansleep(external->led_en, 1);
gpio_set_value_cansleep(external->led_flash_en, 1);
break;
case MSM_CAMERA_LED_HIGH:
CDBG("MSM_CAMERA_LED_HIGH\n");
gpio_set_value_cansleep(external->led_en, 1);
gpio_set_value_cansleep(external->led_flash_en, 1);
break;
default:
rc = -EFAULT;
break;
}
return rc;
#endif
}
static void flash_wq_function(struct work_struct *work)
{
if (tps61310_client) {
i2c_client.client = tps61310_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
msm_camera_i2c_write(&i2c_client, 0x01,
0x46, MSM_CAMERA_I2C_BYTE_DATA);
}
return;
}
void flash_timer_callback(unsigned long data)
{
queue_work(flash_wq, (struct work_struct *)work );
mod_timer(&flash_timer, jiffies + msecs_to_jiffies(10000));
}
int msm_camera_flash_external(
struct msm_camera_sensor_flash_external *external,
unsigned led_state)
{
int rc = 0;
switch (led_state) {
case MSM_CAMERA_LED_INIT:
if (external->flash_id == MAM_CAMERA_EXT_LED_FLASH_SC628A) {
if (!sc628a_client) {
rc = i2c_add_driver(&sc628a_i2c_driver);
if (rc < 0 || sc628a_client == NULL) {
pr_err("sc628a_i2c_driver add failed\n");
rc = -ENOTSUPP;
return rc;
}
}
} else if (external->flash_id ==
MAM_CAMERA_EXT_LED_FLASH_TPS61310) {
if (!tps61310_client) {
rc = i2c_add_driver(&tps61310_i2c_driver);
if (rc < 0 || tps61310_client == NULL) {
pr_err("tps61310_i2c_driver add failed\n");
rc = -ENOTSUPP;
return rc;
}
}
} else {
pr_err("Flash id not supported\n");
rc = -ENOTSUPP;
return rc;
}
#if defined(CONFIG_GPIO_SX150X) || defined(CONFIG_GPIO_SX150X_MODULE)
if (external->expander_info && !sx150x_client) {
struct i2c_adapter *adapter =
i2c_get_adapter(external->expander_info->bus_id);
if (adapter)
sx150x_client = i2c_new_device(adapter,
external->expander_info->board_info);
if (!sx150x_client || !adapter) {
pr_err("sx150x_client is not available\n");
rc = -ENOTSUPP;
if (sc628a_client) {
i2c_del_driver(&sc628a_i2c_driver);
sc628a_client = NULL;
}
if (tps61310_client) {
i2c_del_driver(&tps61310_i2c_driver);
tps61310_client = NULL;
}
return rc;
}
i2c_put_adapter(adapter);
}
#endif
if (sc628a_client)
rc = gpio_request(external->led_en, "sc628a");
if (tps61310_client)
rc = gpio_request(external->led_en, "tps61310");
if (!rc) {
gpio_direction_output(external->led_en, 0);
} else {
goto error;
}
if (sc628a_client)
rc = gpio_request(external->led_flash_en, "sc628a");
if (tps61310_client)
rc = gpio_request(external->led_flash_en, "tps61310");
if (!rc) {
gpio_direction_output(external->led_flash_en, 0);
break;
}
if (sc628a_client || tps61310_client) {
gpio_set_value_cansleep(external->led_en, 0);
gpio_free(external->led_en);
}
error:
pr_err("%s gpio request failed\n", __func__);
if (sc628a_client) {
i2c_del_driver(&sc628a_i2c_driver);
sc628a_client = NULL;
}
if (tps61310_client) {
i2c_del_driver(&tps61310_i2c_driver);
tps61310_client = NULL;
}
break;
case MSM_CAMERA_LED_RELEASE:
if (sc628a_client || tps61310_client) {
gpio_set_value_cansleep(external->led_en, 0);
gpio_free(external->led_en);
gpio_set_value_cansleep(external->led_flash_en, 0);
gpio_free(external->led_flash_en);
if (sc628a_client) {
i2c_del_driver(&sc628a_i2c_driver);
sc628a_client = NULL;
}
if (tps61310_client) {
if (timer_state) {
del_timer(&flash_timer);
kfree((void *)work);
timer_state = 0;
}
i2c_del_driver(&tps61310_i2c_driver);
tps61310_client = NULL;
}
}
#if defined(CONFIG_GPIO_SX150X) || defined(CONFIG_GPIO_SX150X_MODULE)
if (external->expander_info && sx150x_client) {
i2c_unregister_device(sx150x_client);
sx150x_client = NULL;
}
#endif
break;
case MSM_CAMERA_LED_OFF:
if (sc628a_client || tps61310_client) {
if (sc628a_client) {
i2c_client.client = sc628a_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
rc = msm_camera_i2c_write(&i2c_client, 0x02,
0x00, MSM_CAMERA_I2C_BYTE_DATA);
}
if (tps61310_client) {
i2c_client.client = tps61310_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
rc = msm_camera_i2c_write(&i2c_client, 0x01,
0x00, MSM_CAMERA_I2C_BYTE_DATA);
if (timer_state) {
del_timer(&flash_timer);
kfree((void *)work);
timer_state = 0;
}
}
gpio_set_value_cansleep(external->led_en, 0);
gpio_set_value_cansleep(external->led_flash_en, 0);
}
break;
case MSM_CAMERA_LED_LOW:
if (sc628a_client || tps61310_client) {
gpio_set_value_cansleep(external->led_en, 1);
gpio_set_value_cansleep(external->led_flash_en, 1);
usleep_range(2000, 3000);
if (sc628a_client) {
i2c_client.client = sc628a_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
rc = msm_camera_i2c_write(&i2c_client, 0x02,
0x06, MSM_CAMERA_I2C_BYTE_DATA);
}
if (tps61310_client) {
i2c_client.client = tps61310_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
rc = msm_camera_i2c_write(&i2c_client, 0x01,
0x46, MSM_CAMERA_I2C_BYTE_DATA);
flash_wq = create_workqueue("my_queue");
work = (struct flash_work *)kmalloc(sizeof(struct flash_work), GFP_KERNEL);
INIT_WORK( (struct work_struct *)work, flash_wq_function );
setup_timer(&flash_timer, flash_timer_callback, 0);
mod_timer(&flash_timer, jiffies + msecs_to_jiffies(10000));
timer_state = 1;
}
}
break;
case MSM_CAMERA_LED_HIGH:
if (sc628a_client || tps61310_client) {
gpio_set_value_cansleep(external->led_en, 1);
gpio_set_value_cansleep(external->led_flash_en, 1);
usleep_range(2000, 3000);
if (sc628a_client) {
i2c_client.client = sc628a_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
rc = msm_camera_i2c_write(&i2c_client, 0x02,
0x49, MSM_CAMERA_I2C_BYTE_DATA);
}
if (tps61310_client) {
i2c_client.client = tps61310_client;
i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
rc = msm_camera_i2c_write(&i2c_client, 0x01,
0x8B, MSM_CAMERA_I2C_BYTE_DATA);
}
}
break;
default:
rc = -EFAULT;
break;
}
return rc;
}
static int msm_camera_flash_pwm(
struct msm_camera_sensor_flash_pwm *pwm,
unsigned led_state)
{
int rc = 0;
int PWM_PERIOD = USEC_PER_SEC / pwm->freq;
static struct pwm_device *flash_pwm;
if (!flash_pwm) {
flash_pwm = pwm_request(pwm->channel, "camera-flash");
if (flash_pwm == NULL || IS_ERR(flash_pwm)) {
pr_err("%s: FAIL pwm_request(): flash_pwm=%p\n",
__func__, flash_pwm);
flash_pwm = NULL;
return -ENXIO;
}
}
switch (led_state) {
case MSM_CAMERA_LED_LOW:
rc = pwm_config(flash_pwm,
(PWM_PERIOD/pwm->max_load)*pwm->low_load,
PWM_PERIOD);
if (rc >= 0)
rc = pwm_enable(flash_pwm);
break;
case MSM_CAMERA_LED_HIGH:
rc = pwm_config(flash_pwm,
(PWM_PERIOD/pwm->max_load)*pwm->high_load,
PWM_PERIOD);
if (rc >= 0)
rc = pwm_enable(flash_pwm);
break;
case MSM_CAMERA_LED_OFF:
pwm_disable(flash_pwm);
break;
case MSM_CAMERA_LED_INIT:
case MSM_CAMERA_LED_RELEASE:
break;
default:
rc = -EFAULT;
break;
}
return rc;
}
int msm_camera_flash_pmic(
struct msm_camera_sensor_flash_pmic *pmic,
unsigned led_state)
{
int rc = 0;
switch (led_state) {
case MSM_CAMERA_LED_OFF:
rc = pmic->pmic_set_current(pmic->led_src_1, 0);
if (pmic->num_of_src > 1)
rc = pmic->pmic_set_current(pmic->led_src_2, 0);
break;
case MSM_CAMERA_LED_LOW:
rc = pmic->pmic_set_current(pmic->led_src_1,
pmic->low_current);
if (pmic->num_of_src > 1)
rc = pmic->pmic_set_current(pmic->led_src_2, 0);
break;
case MSM_CAMERA_LED_HIGH:
rc = pmic->pmic_set_current(pmic->led_src_1,
pmic->high_current);
if (pmic->num_of_src > 1)
rc = pmic->pmic_set_current(pmic->led_src_2,
pmic->high_current);
break;
case MSM_CAMERA_LED_INIT:
case MSM_CAMERA_LED_RELEASE:
break;
default:
rc = -EFAULT;
break;
}
CDBG("flash_set_led_state: return %d\n", rc);
return rc;
}
int backlight_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,
};
/* 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()
|| machine_is_msm8255_u8860()
|| machine_is_msm8255_c8860()
|| machine_is_msm8255_u8860lp()
|| machine_is_msm8255_u8860_r()
|| machine_is_msm8255_u8860_92()
|| machine_is_msm8255_u8680()
|| machine_is_msm8255_u8667()
|| machine_is_msm8255_u8860_51()
|| machine_is_msm8255_u8730())
{
rc = pm8xxx_gpio_config( 24, &backlight_drv);
}
else if(machine_is_msm7x30_u8820())
{
rc = pm8xxx_gpio_config( 25, &backlight_drv);
}
else
{
rc = -1;
}
if (rc)
{
pr_err("%s LCD backlight GPIO config failed\n", __func__);
return rc;
}
return 0;
}
/* use the mmp pin like three-leds */
void msm_backlight_set(int level)
{
static uint8 last_level = 0;
/*fix bug in new base-line 1025*/
#ifdef CONFIG_ARCH_MSM7X30
static boolean first_set_bl = TRUE;
static struct pwm_device *bl_pwm;
#endif //CONFIG_ARCH_MSM7X30
/* keep duty 10% < level < 100% */
#ifdef CONFIG_ARCH_MSM7X27A
if(level)
{
#ifdef CONFIG_HUAWEI_OLD_BACKLIGHT
level = ((level * PWM_LEVEL_ADJUST_LPG) / PWM_LEVEL );
if (level < BL_MIN_LEVEL_LPG)
{
level = BL_MIN_LEVEL_LPG;
}
#else
if (level < BL_MIN_LEVEL)
{
level = BL_MIN_LEVEL;
}
#endif
}
if (last_level == level)
{
return ;
}
last_level = level;
pmapp_disp_backlight_set_brightness(last_level);
#endif
#ifdef CONFIG_ARCH_MSM7X30
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()
|| machine_is_msm8255_u8860()
|| machine_is_msm8255_c8860()
|| machine_is_msm8255_u8860lp()
|| machine_is_msm8255_u8860_r()
|| machine_is_msm8255_u8860_92()
|| machine_is_msm8255_u8680()
|| machine_is_msm8255_u8667()
|| machine_is_msm8255_u8860_51()
|| machine_is_msm8255_u8730())
{
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)
{
if(level)
{
level = ((level * PWM_LEVEL_ADJUST) / PWM_LEVEL + ADD_VALUE);
if (level < BL_MIN_LEVEL)
{
level = BL_MIN_LEVEL;
}
}
if (last_level == level)
{
return ;
}
last_level = level;
pwm_config(bl_pwm, PWM_DUTY_LEVEL*level/NSEC_PER_USEC, PWM_PERIOD/NSEC_PER_USEC);
pwm_enable(bl_pwm);
}
#endif
}
void cabc_backlight_set(struct msm_fb_data_type * mfd)
{
struct msm_fb_panel_data *pdata = NULL;
uint32 bl_level = mfd->bl_level;
/* keep duty 10% < level < 100% */
if (bl_level)
{
/****delete one line codes for backlight*****/
if (bl_level < BL_MIN_LEVEL)
{
bl_level = BL_MIN_LEVEL;
}
}
/* backlight ctrl by LCD-self, like as CABC */
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
if ((pdata) && (pdata->set_cabc_brightness))
{
pdata->set_cabc_brightness(mfd,bl_level);
}
}
void pwm_set_backlight(struct msm_fb_data_type *mfd)
{
#ifdef CONFIG_HUAWEI_OLD_BACKLIGHT
lcd_panel_type lcd_panel_wvga = LCD_NONE;
#endif
/*When all the device are resume that can turn the light*/
if(atomic_read(&suspend_flag))
{
mfd_local = mfd;
backlight_set = TRUE;
return;
}
#ifdef CONFIG_HUAWEI_OLD_BACKLIGHT
lcd_panel_wvga = get_lcd_panel_type();
if ((MIPI_CMD_RSP61408_CHIMEI_WVGA == lcd_panel_wvga )
|| (MIPI_CMD_RSP61408_BYD_WVGA == lcd_panel_wvga )
|| (MIPI_CMD_RSP61408_TRULY_WVGA == lcd_panel_wvga )
|| (MIPI_CMD_HX8369A_TIANMA_WVGA == lcd_panel_wvga ))
{
/* keep duty is 75% of the quondam duty */
mfd->bl_level = mfd->bl_level * 75 / 100;
}
#endif
if (get_hw_lcd_ctrl_bl_type() == CTRL_BL_BY_MSM)
{
msm_backlight_set(mfd->bl_level);
}
else
{
cabc_backlight_set(mfd);
}
return;
}
static void pm8xxx_led_gpio_set(struct led_classdev *led_cdev, enum led_brightness brightness)
{
int rc, offset;
u8 level;
struct pm8xxx_led_data *led = container_of(led_cdev, struct pm8xxx_led_data, cdev);
LED_INFO("%s, bank:%d, brightness:%d sync: %d\n", __func__, led->bank, brightness, led->led_sync);
if (led->gpio_status_switch != NULL)
led->gpio_status_switch(0);
pwm_disable(led->pwm_led);
if(led->led_sync) {
if (!strcmp(led->cdev.name, "green")){
if (green_back_led_data->gpio_status_switch != NULL)
green_back_led_data->gpio_status_switch(0);
pwm_disable(green_back_led_data->pwm_led);
level = ( 0 << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(green_back_led_data->id);
green_back_led_data->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
green_back_led_data->reg |= level;
rc = pm8xxx_writeb(green_back_led_data->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), green_back_led_data->reg);
}
if (!strcmp(led->cdev.name, "amber")){
if (amber_back_led_data->gpio_status_switch != NULL)
amber_back_led_data->gpio_status_switch(0);
pwm_disable(amber_back_led_data->pwm_led);
level = ( 0 << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(amber_back_led_data->id);
amber_back_led_data->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
amber_back_led_data->reg |= level;
rc = pm8xxx_writeb(amber_back_led_data->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), amber_back_led_data->reg);
}
}
if (brightness) {
if (led->gpio_status_switch != NULL)
led->gpio_status_switch(1);
pwm_config(led->pwm_led, 6400 * led->pwm_coefficient / 100, 6400);
pwm_enable(led->pwm_led);
if(led->led_sync) {
if (!strcmp(led->cdev.name, "green")) {
if (green_back_led_data->gpio_status_switch != NULL)
green_back_led_data->gpio_status_switch(1);
level = (green_back_led_data->out_current << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(green_back_led_data->id);
green_back_led_data->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
green_back_led_data->reg |= level;
rc = pm8xxx_writeb(green_back_led_data->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), green_back_led_data->reg);
pwm_config(green_back_led_data->pwm_led, 64000, 64000);
pwm_enable(green_back_led_data->pwm_led);
}
if (!strcmp(led->cdev.name, "amber")) {
if (amber_back_led_data->gpio_status_switch != NULL)
amber_back_led_data->gpio_status_switch(1);
level = (amber_back_led_data->out_current << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(amber_back_led_data->id);
amber_back_led_data->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
amber_back_led_data->reg |= level;
rc = pm8xxx_writeb(amber_back_led_data->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), amber_back_led_data->reg);
pwm_config(amber_back_led_data->pwm_led, 64000, 64000);
pwm_enable(amber_back_led_data->pwm_led);
}
}
}
}
static ssize_t pm8xxx_led_blink_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev;
struct pm8xxx_led_data *ldata;
int val;
int level, offset;
int led_is_green;
val = -1;
sscanf(buf, "%u", &val);
if (val < 0 || val > 255)
return -EINVAL;
current_blink= val;
led_cdev = (struct led_classdev *) dev_get_drvdata(dev);
ldata = container_of(led_cdev, struct pm8xxx_led_data, cdev);
LED_INFO("%s: bank %d blink %d sync %d\n", __func__, ldata->bank, val, ldata->led_sync);
printk("%s: [BB] bank %d blink %d sync %d\n", __func__, ldata->bank, val, ldata->led_sync);
if (!strcmp(ldata->cdev.name, "green")) {
led_is_green = 1;
}
if (!strcmp(ldata->cdev.name, "amber")) {
led_is_green = 0;
}
switch (val) {
case BLINK_STOP:
if (ldata->gpio_status_switch != NULL)
ldata->gpio_status_switch(0);
pwm_disable(ldata->pwm_led);
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")) {
if (green_back_led_data->gpio_status_switch != NULL)
green_back_led_data->gpio_status_switch(0);
pwm_disable(green_back_led_data->pwm_led);
}
if (!strcmp(ldata->cdev.name, "amber")) {
if (amber_back_led_data->gpio_status_switch != NULL)
amber_back_led_data->gpio_status_switch(0);
pwm_disable(amber_back_led_data->pwm_led);
}
}
if (blink_buttons > 0) {
if (led_is_green == 1) {
green_blink_value = 0;
} else {
amber_blink_value = 0;
}
pm8xxx_buttons_blink(0);
}
break;
case BLINK_UNCHANGE:
pwm_disable(ldata->pwm_led);
if (led_cdev->brightness) {
if (ldata->gpio_status_switch != NULL)
ldata->gpio_status_switch(1);
pwm_config(ldata->pwm_led, 6400 * ldata->pwm_coefficient / 100, 6400);
pwm_enable(ldata->pwm_led);
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")) {
if (green_back_led_data->gpio_status_switch != NULL)
green_back_led_data->gpio_status_switch(1);
pwm_config(green_back_led_data->pwm_led, 64000, 64000);
pwm_enable(green_back_led_data->pwm_led);
}
if (!strcmp(ldata->cdev.name, "amber")) {
if (amber_back_led_data->gpio_status_switch != NULL)
amber_back_led_data->gpio_status_switch(1);
pwm_config(amber_back_led_data->pwm_led, 64000, 64000);
pwm_enable(amber_back_led_data->pwm_led);
}
}
if (blink_buttons > 0 && val > 0) {
if (led_is_green == 1) {
green_blink_value = 1;
} else {
amber_blink_value = 1;
}
pm8xxx_buttons_blink(1);
}
} else {
pwm_disable(ldata->pwm_led);
if (ldata->gpio_status_switch != NULL)
ldata->gpio_status_switch(0);
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")){
if (green_back_led_data->gpio_status_switch != NULL)
green_back_led_data->gpio_status_switch(0);
pwm_disable(green_back_led_data->pwm_led);
level = ( 0 << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(green_back_led_data->id);
green_back_led_data->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
green_back_led_data->reg |= level;
pm8xxx_writeb(green_back_led_data->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), green_back_led_data->reg);
}
if (!strcmp(ldata->cdev.name, "amber")){
if (amber_back_led_data->gpio_status_switch != NULL)
amber_back_led_data->gpio_status_switch(0);
pwm_disable(amber_back_led_data->pwm_led);
level = ( 0 << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;
offset = PM8XXX_LED_OFFSET(amber_back_led_data->id);
amber_back_led_data->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;
amber_back_led_data->reg |= level;
pm8xxx_writeb(amber_back_led_data->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), amber_back_led_data->reg);
}
}
if (blink_buttons > 0) {
if (led_is_green == 1) {
green_blink_value = 0;
} else {
amber_blink_value = 0;
}
pm8xxx_buttons_blink(0);
}
}
break;
case BLINK_64MS_PER_2SEC:
if (ldata->gpio_status_switch != NULL)
ldata->gpio_status_switch(1);
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, ldata->blink_duty_per_2sec, 2000000);
pwm_enable(ldata->pwm_led);
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")) {
if (green_back_led_data->gpio_status_switch != NULL)
green_back_led_data->gpio_status_switch(1);
pwm_disable(green_back_led_data->pwm_led);
pwm_config(green_back_led_data->pwm_led, ldata->blink_duty_per_2sec, 2000000);
pwm_enable(green_back_led_data->pwm_led);
}
if (!strcmp(ldata->cdev.name, "amber")) {
if (amber_back_led_data->gpio_status_switch != NULL)
amber_back_led_data->gpio_status_switch(1);
pwm_disable(amber_back_led_data->pwm_led);
pwm_config(amber_back_led_data->pwm_led, ldata->blink_duty_per_2sec, 2000000);
pwm_enable(amber_back_led_data->pwm_led);
}
}
if (blink_buttons > 0 && val > 0) {
if (led_is_green == 1) {
green_blink_value = 1;
} else {
amber_blink_value = 1;
}
pm8xxx_buttons_blink(1);
}
break;
case BLINK_64MS_ON_310MS_PER_2SEC:
cancel_delayed_work_sync(&ldata->blink_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")) {
pwm_disable(green_back_led_data->pwm_led);
green_back_led_data->duty_time_ms = 64;
green_back_led_data->period_us = 2000000;
}
if (!strcmp(ldata->cdev.name, "amber")) {
pwm_disable(amber_back_led_data->pwm_led);
amber_back_led_data->duty_time_ms = 64;
amber_back_led_data->period_us = 2000000;
}
}
queue_delayed_work(g_led_work_queue, &ldata->blink_delayed_work,
msecs_to_jiffies(310));
break;
case BLINK_64MS_ON_2SEC_PER_2SEC:
cancel_delayed_work_sync(&ldata->blink_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")) {
pwm_disable(green_back_led_data->pwm_led);
green_back_led_data->duty_time_ms = 64;
green_back_led_data->period_us = 2000000;
}
if (!strcmp(ldata->cdev.name, "amber")) {
pwm_disable(amber_back_led_data->pwm_led);
amber_back_led_data->duty_time_ms = 64;
amber_back_led_data->period_us = 2000000;
}
}
queue_delayed_work(g_led_work_queue, &ldata->blink_delayed_work,
msecs_to_jiffies(1000));
break;
case BLINK_1SEC_PER_2SEC:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 1000000, 2000000);
pwm_enable(ldata->pwm_led);
if(ldata->led_sync) {
if (!strcmp(ldata->cdev.name, "green")) {
pwm_disable(green_back_led_data->pwm_led);
pwm_config(green_back_led_data->pwm_led, 1000000, 2000000);
pwm_enable(green_back_led_data->pwm_led);
}
if (!strcmp(ldata->cdev.name, "amber")) {
pwm_disable(amber_back_led_data->pwm_led);
pwm_config(amber_back_led_data->pwm_led, 1000000, 2000000);
pwm_enable(amber_back_led_data->pwm_led);
}
}
break;
default:
LED_ERR("%s: bank %d did not support blink type %d\n", __func__, ldata->bank, val);
return -EINVAL;
}
return count;
}
static ssize_t pm8058_led_blink_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev;
struct pm8058_led_data *ldata;
int val;
/*struct timespec ts1, ts2;*/
val = -1;
sscanf(buf, "%u", &val);
if (val < 0 || val > 255)
return -EINVAL;
led_cdev = (struct led_classdev *)dev_get_drvdata(dev);
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
/*printk(KERN_INFO "blink %s: %d\n", ldata->ldev.name, val);*/
switch (val) {
case -1: /* stop flashing */
pwm_disable(ldata->pwm_led);
break;
case 0:
pwm_disable(ldata->pwm_led);
if (led_cdev->brightness) {
pwm_config(ldata->pwm_led, 64000, 64000);
pwm_enable(ldata->pwm_led);
}
break;
case 1:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 64000, 2000000);
pwm_enable(ldata->pwm_led);
break;
case 2:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
/*getnstimeofday(&ts1);
printk(" at %09lu\n", ts1.tv_nsec);
msleep(310);
getnstimeofday(&ts2);
printk(" at %09lu\n", ts2.tv_nsec);
*/
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(310));
break;
case 3:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(1000));
break;
case 4:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 1000000, 2000000);
/* pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_1KHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_2;
pwm_conf.pre_div_exp = 1;
pwm_conf.pwm_value = 512/2;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
*/
pwm_enable(ldata->pwm_led);
break;
default:
return -EINVAL;
}
return count;
}
