static int __devexit pm8058_led_remove(struct platform_device *pdev)
{
struct pm8058_led_platform_data *pdata;
struct pm8058_led_data *ldata;
int i;
pdata = pdev->dev.platform_data;
ldata = platform_get_drvdata(pdev);
for (i = 0; i < pdata->num_leds; i++) {
led_classdev_unregister(&ldata[i].ldev);
switch (pdata->led_config[i].type) {
case PM8058_LED_RGB:
device_remove_file(ldata[i].ldev.dev,
&dev_attr_blink);
device_remove_file(ldata[i].ldev.dev,
&dev_attr_off_timer);
pwm_free(ldata[i].pwm_led);
break;
case PM8058_LED_PWM:
case PM8058_LED_DRVX:
pwm_free(ldata[i].pwm_led);
break;
}
}
destroy_workqueue(g_led_work_queue);
kfree(ldata);
return 0;
}
static int pwm_fan_remove(struct platform_device *pdev)
{
struct fan_dev_data *fan_data = platform_get_drvdata(pdev);
if (!fan_data)
return -EINVAL;
debugfs_remove_recursive(fan_debugfs_root);
free_irq(fan_data->tach_irq, NULL);
gpio_free(fan_data->tach_gpio);
pwm_config(fan_data->pwm_dev, 0, fan_data->pwm_period);
pwm_disable(fan_data->pwm_dev);
pwm_free(fan_data->pwm_dev);
thermal_cooling_device_unregister(fan_data->cdev);
cancel_delayed_work(&fan_data->fan_tach_work);
destroy_workqueue(fan_data->tach_workqueue);
cancel_delayed_work(&fan_data->fan_ramp_work);
destroy_workqueue(fan_data->workqueue);
devm_kfree(&pdev->dev, (void *)(fan_data->fan_pwm));
devm_kfree(&pdev->dev, (void *)(fan_data->fan_state_cap_lookup));
devm_kfree(&pdev->dev, (void *)(fan_data->fan_rrd));
devm_kfree(&pdev->dev, (void *)(fan_data->fan_rru));
devm_kfree(&pdev->dev, (void *)(fan_data->fan_rpm));
devm_kfree(&pdev->dev, (void *)fan_data);
remove_sysfs_entry(&pdev->dev);
if (fan_data->fan_reg)
regulator_put(fan_data->fan_reg);
return 0;
}
static int pwm_fan_suspend(struct platform_device *pdev, pm_message_t state)
{
struct fan_dev_data *fan_data = platform_get_drvdata(pdev);
int err;
mutex_lock(&fan_data->fan_state_lock);
cancel_delayed_work(&fan_data->fan_ramp_work);
/*Turn the fan off*/
fan_data->fan_cur_pwm = 0;
fan_data->next_target_pwm = 0;
set_pwm_duty_cycle(0, fan_data);
pwm_disable(fan_data->pwm_dev);
pwm_free(fan_data->pwm_dev);
err = gpio_request(fan_data->pwm_gpio, "pwm-fan");
if (err < 0) {
dev_err(&pdev->dev, "%s:gpio request failed %d\n",
__func__, fan_data->pwm_gpio);
}
gpio_direction_output(fan_data->pwm_gpio, 1);
/*Stop thermal control*/
fan_data->fan_temp_control_flag = 0;
mutex_unlock(&fan_data->fan_state_lock);
return 0;
}
static int pwm_backlight_remove(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
struct backlight_device *bl = platform_get_drvdata(pdev);
struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
struct pin_config new_pin_config;
backlight_device_unregister(bl);
pwm_config(pb->pwm, 0, pb->period);
pwm_disable(pb->pwm);
pwm_free(pb->pwm);
if (data && data->exit)
data->exit(&pdev->dev);
if (data && pdev->dev.of_node) {
kfree(data);
pdev->dev.platform_data = NULL;
}
/*reset the pwm pin to GPIO function if defined in the kernel-dtb*/
if (pwm_pin >= 0 && pwm_pin_reboot_func >= 0) {
pr_info("remove reset the pwm pin to GPIO function\r\n");
pr_err("remove reset the pwm pin to GPIO function\r\n");
new_pin_config.name = pwm_pin;
pinmux_get_pin_config(&new_pin_config);
new_pin_config.func = pwm_pin_reboot_func;
pinmux_set_pin_config(&new_pin_config);
gpio_direction_output( 24, 0 );
gpio_set_value( 24, 0 );
}
return 0;
}
static int pwm_backlight_probe(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
struct backlight_device *bl;
struct pwm_bl_data *pb;
int ret;
if (!data) {
dev_err(&pdev->dev, "failed to find platform data\n");
return -EINVAL;
}
if (data->init) {
ret = data->init(&pdev->dev);
if (ret < 0)
return ret;
}
pb = kzalloc(sizeof(*pb), GFP_KERNEL);
if (!pb) {
dev_err(&pdev->dev, "no memory for state\n");
ret = -ENOMEM;
goto err_alloc;
}
pb->period = data->pwm_period_ns;
pb->notify = data->notify;
pb->pwm = pwm_request(data->pwm_id, "backlight");
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request PWM for backlight\n");
ret = PTR_ERR(pb->pwm);
goto err_pwm;
} else
dev_dbg(&pdev->dev, "got pwm for backlight\n");
bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev,
pb, &pwm_backlight_ops);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
ret = PTR_ERR(bl);
goto err_bl;
}
bl->props.max_brightness = data->max_brightness;
bl->props.brightness = data->dft_brightness;
backlight_update_status(bl);
platform_set_drvdata(pdev, bl);
return 0;
err_bl:
pwm_free(pb->pwm);
err_pwm:
kfree(pb);
err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}
static int __devinit pwm_beeper_probe(struct platform_device *pdev)
{
unsigned long pwm_id = (unsigned long)pdev->dev.platform_data;
struct pwm_beeper *beeper;
int error;
beeper = kzalloc(sizeof(*beeper), GFP_KERNEL);
if (!beeper)
return -ENOMEM;
beeper->pwm = pwm_request(pwm_id, "pwm beeper");
if (IS_ERR(beeper->pwm)) {
error = PTR_ERR(beeper->pwm);
dev_err(&pdev->dev, "Failed to request pwm device: %d\n", error);
goto err_free;
}
beeper->input = input_allocate_device();
if (!beeper->input) {
dev_err(&pdev->dev, "Failed to allocate input device\n");
error = -ENOMEM;
goto err_pwm_free;
}
beeper->input->dev.parent = &pdev->dev;
beeper->input->name = "pwm-beeper";
beeper->input->phys = "pwm/input0";
beeper->input->id.bustype = BUS_HOST;
beeper->input->id.vendor = 0x001f;
beeper->input->id.product = 0x0001;
beeper->input->id.version = 0x0100;
beeper->input->evbit[0] = BIT(EV_SND);
beeper->input->sndbit[0] = BIT(SND_TONE) | BIT(SND_BELL);
beeper->input->event = pwm_beeper_event;
input_set_drvdata(beeper->input, beeper);
error = input_register_device(beeper->input);
if (error) {
dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
goto err_input_free;
}
platform_set_drvdata(pdev, beeper);
return 0;
err_input_free:
input_free_device(beeper->input);
err_pwm_free:
pwm_free(beeper->pwm);
err_free:
kfree(beeper);
return error;
}
static void rx1950_backlight_exit(struct device *dev)
{
rx1950_bl_power(0);
rx1950_lcd_power(0);
pwm_free(lcd_pwm);
gpio_free(S3C2410_GPB(0));
}
static int star_vib_remove(struct platform_device *dev)
{
// struct platform_device* pdev = to_platform_device(dev);
// struct pwm_vib_data* pvib = platform_get_drvdata(pdev);
pwm_free(pvib->pwm);
return 0;
}
static int __devexit vibrator_remove(struct platform_device *pdev)
{
struct vibrator_drvdata *data = platform_get_drvdata(pdev);
timed_output_dev_unregister(&data->dev);
regulator_put(data->regulator);
pwm_free(data->pwm);
kfree(data);
return 0;
}
static __devexit int acx00_i2c_remove(struct i2c_client *i2c)
{
struct acx00 *acx00 = i2c_get_clientdata(i2c);
acx00_device_exit(acx00);
pwm_disable(acx00->pwm_ac200);
pwm_free(acx00->pwm_ac200);
return 0;
}
static int __devinit pwm_ir_tx_probe(struct pwm_ir_dev *dev)
{
struct pwm_ir_data *data = dev->pdev->dev.platform_data;
int rc = 0;
if (data->reg_id) {
dev->reg = regulator_get(&dev->pdev->dev, data->reg_id);
if (IS_ERR(dev->reg)) {
dev_err(&dev->pdev->dev,
"failed to regulator_get(%s)\n",
data->reg_id);
return PTR_ERR(dev->reg);
}
}
dev->pwm = pwm_request(data->pwm_id, PWM_IR_NAME);
if (IS_ERR(dev->pwm)) {
dev_err(&dev->pdev->dev,
"failed to pwm_request(%d)\n",
data->pwm_id);
rc = PTR_ERR(dev->pwm);
goto err_regulator_put;
}
if (data->low_active) {
#if 0 /* need the latest kernel */
rc = pwm_set_polarity(dev->pwm, PWM_POLARITY_INVERSED);
#else
rc = -ENOSYS;
#endif
if (rc != 0) {
dev_err(&dev->pdev->dev, "failed to change polarity\n");
goto err_pwm_free;
}
}
rc = pwm_ir_tx_config(dev, 38000, 50);
if (rc != 0) {
dev_err(&dev->pdev->dev, "failed to change carrier and duty\n");
goto err_pwm_free;
}
dev->rdev->tx_ir = pwm_ir_tx_transmit;
dev->rdev->s_tx_carrier = pwm_ir_tx_carrier;
dev->rdev->s_tx_duty_cycle = pwm_ir_tx_duty_cycle;
return rc;
err_pwm_free:
pwm_free(dev->pwm);
err_regulator_put:
if (dev->reg)
regulator_put(dev->reg);
return rc;
}
static int shooter_u_3Dpanel_remove(struct platform_device * pdev)
{
printk(KERN_INFO "%s\n", __func__);
if (pwm_3d) {
pwm_free(pwm_3d);
pwm_3d = NULL;
}
device_remove_file(&pdev->dev, &dev_attr_3D_mode);
kobject_del(uevent_kobj);
kobject_del(kobj);
return 0;
}
static int __devexit pm8058_led_remove(struct platform_device *pdev)
{
struct pm8058_led_platform_data *pdata;
struct pm8058_led_data *ldata;
int i;
pdata = pdev->dev.platform_data;
ldata = platform_get_drvdata(pdev);
for (i = 0; i < pdata->num_leds; i++) {
led_classdev_unregister(&ldata[i].ldev);
switch (pdata->led_config[i].type) {
case PM8058_LED_RGB:
pwm_free(ldata[i].pwm_led);
break;
case PM8058_LED_PWM:
case PM8058_LED_DRVX:
pwm_free(ldata[i].pwm_led);
break;
}
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
device_remove_file(ldata[i].ldev.dev,
&dev_attr_blink);
device_remove_file(ldata[i].ldev.dev,
&dev_attr_off_timer);
}
if (ldata[i].bank >= 3)
device_remove_file(ldata[i].ldev.dev,
&dev_attr_currents);
}
wake_lock_destroy(&pmic_led_wake_lock);
destroy_workqueue(g_led_work_queue);
kfree(ldata);
return 0;
}
/* configuration api for pwm */
static int qpnp_hap_pwm_config(struct qpnp_hap *hap)
{
u8 reg = 0;
int rc, temp;
/* Configure the EXTERNAL_PWM register */
if (hap->ext_pwm_freq_khz <= QPNP_HAP_EXT_PWM_FREQ_25_KHZ) {
hap->ext_pwm_freq_khz = QPNP_HAP_EXT_PWM_FREQ_25_KHZ;
temp = 0;
} else if (hap->ext_pwm_freq_khz <=
QPNP_HAP_EXT_PWM_FREQ_50_KHZ) {
hap->ext_pwm_freq_khz = QPNP_HAP_EXT_PWM_FREQ_50_KHZ;
temp = 1;
} else if (hap->ext_pwm_freq_khz <=
QPNP_HAP_EXT_PWM_FREQ_75_KHZ) {
hap->ext_pwm_freq_khz = QPNP_HAP_EXT_PWM_FREQ_75_KHZ;
temp = 2;
} else {
hap->ext_pwm_freq_khz = QPNP_HAP_EXT_PWM_FREQ_100_KHZ;
temp = 3;
}
rc = qpnp_hap_read_reg(hap, ®,
QPNP_HAP_EXT_PWM_REG(hap->base));
if (rc < 0)
return rc;
reg &= QPNP_HAP_EXT_PWM_MASK;
reg |= temp;
rc = qpnp_hap_write_reg(hap, ®,
QPNP_HAP_EXT_PWM_REG(hap->base));
if (rc)
return rc;
hap->pwm_info.pwm_dev = pwm_request(hap->pwm_info.pwm_channel,
"qpnp-hap");
if (IS_ERR_OR_NULL(hap->pwm_info.pwm_dev)) {
dev_err(&hap->spmi->dev, "hap pwm request failed\n");
return -ENODEV;
}
rc = pwm_config(hap->pwm_info.pwm_dev, hap->pwm_info.duty_us,
hap->pwm_info.period_us);
if (rc < 0) {
dev_err(&hap->spmi->dev, "hap pwm config failed\n");
pwm_free(hap->pwm_info.pwm_dev);
return -ENODEV;
}
hap->pwm_cfg_state = true;
return 0;
}
static int pwm_beeper_remove(struct platform_device *pdev)
{
struct pwm_beeper *beeper = platform_get_drvdata(pdev);
input_unregister_device(beeper->input);
pwm_disable(beeper->pwm);
pwm_free(beeper->pwm);
kfree(beeper);
return 0;
}
static int __devexit vibrator_remove(struct platform_device *pdev)
{
struct vibrator_drvdata *data = platform_get_drvdata(pdev);
timed_output_dev_unregister(&data->dev);
#ifdef CONFIG_MACH_Q1_BD
gpio_free(GPIO_MOTOR_EN);
#else
regulator_put(data->regulator);
#endif
pwm_free(data->pwm);
kfree(data);
return 0;
}
static int pwm_backlight_remove(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
struct backlight_device *bl = platform_get_drvdata(pdev);
struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
backlight_device_unregister(bl);
pwm_config(pb->pwm, 0, pb->period);
pwm_disable(pb->pwm);
pwm_free(pb->pwm);
if (data->exit)
data->exit(&pdev->dev);
return 0;
}
static int max77660_haptic_remove(struct platform_device *pdev)
{
struct max77660_haptic *chip = platform_get_drvdata(pdev);
destroy_work_on_stack(&chip->work);
input_unregister_device(chip->input_dev);
sysfs_remove_group(&pdev->dev.kobj, &max77660_haptics_attr_group);
regulator_put(chip->regulator);
if (chip->mode == MAX77660_EXTERNAL_MODE)
pwm_free(chip->pwm);
return 0;
}
static int __devexit max77693_haptic_remove(struct platform_device *pdev)
{
struct max77693_haptic_data *data = platform_get_drvdata(pdev);
#ifdef CONFIG_ANDROID_TIMED_OUTPUT
timed_output_dev_unregister(&data->tout_dev);
#endif
regulator_put(data->regulator);
pwm_free(data->pwm);
destroy_workqueue(data->workqueue);
kfree(data);
g_hap_data = NULL;
return 0;
}
static int __devexit max8997_haptic_remove(struct platform_device *pdev)
{
struct max8997_haptic *chip = platform_get_drvdata(pdev);
input_unregister_device(chip->input_dev);
regulator_put(chip->regulator);
if (chip->mode == MAX8997_EXTERNAL_MODE)
pwm_free(chip->pwm);
kfree(chip);
return 0;
}
static void vibrator_free(struct platform_device *pdev)
{
/* struct ast_tspdrv_platform_data *pdata = */
/* (struct ast_tspdev_platform_data *) pdev->dev.platform_data; */
ast_dock_notifier_unregister(&haptic_vibrator->dock_notifier);
timed_output_dev_unregister(&ast_vibrator);
pwm_free(haptic_vibrator->pwm);
if (haptic_vibrator->reg != NULL) {
regulator_disable(haptic_vibrator->reg);
regulator_put(haptic_vibrator->reg);
}
kfree(haptic_vibrator);
}
static int msm_pmic_led_suspend(struct platform_device *dev,
pm_message_t state)
{
/* if phone is set in system sleep indicator mode and is sleepping,bl_pwm must be free for GPIO_24 is being controled by modem*/
#ifdef CONFIG_HUAWEI_LEDS_PMIC
if( machine_is_msm8255_u8860lp()
|| machine_is_msm8255_u8860_r()
||machine_is_msm8255_u8860_51())
{
pwm_free(bl_pwm);
}
#endif
led_classdev_suspend(&msm_kp_bl_led);
return 0;
}
static int pwm_backlight_remove(struct platform_device *pdev)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
struct pwm_bl_data *pb = bl_get_data(bl);
backlight_device_unregister(bl);
pwm_backlight_power_off(pb);
if (pb->exit)
pb->exit(&pdev->dev);
if (pb->legacy)
pwm_free(pb->pwm);
return 0;
}
static int __init herring_init_vibrator(void)
{
int ret = 0;
#ifdef CONFIG_MACH_HERRING
if (!machine_is_herring())
return 0;
#endif
hrtimer_init(&vibdata.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vibdata.timer.function = herring_vibrator_timer_func;
INIT_WORK(&vibdata.work, herring_vibrator_work);
ret = gpio_request(GPIO_VIBTONE_EN1, "vibrator-en");
if (ret < 0)
return ret;
s3c_gpio_cfgpin(GPIO_VIBTONE_PWM, GPD0_TOUT_1);
vibdata.pwm_dev = pwm_request(1, "vibrator-pwm");
if (IS_ERR(vibdata.pwm_dev)) {
ret = PTR_ERR(vibdata.pwm_dev);
goto err_pwm_req;
}
wake_lock_init(&vibdata.wklock, WAKE_LOCK_SUSPEND, "vibrator");
mutex_init(&vibdata.lock);
ret = timed_output_dev_register(&to_dev);
if (ret < 0)
goto err_to_dev_reg;
if (misc_register(&pwm_duty_device))
printk("%s misc_register(%s) failed\n", __FUNCTION__, pwm_duty_device.name);
else {
if (sysfs_create_group(&pwm_duty_device.this_device->kobj, &pwm_duty_group))
dev_err("failed to create sysfs group for device %s\n", pwm_duty_device.name);
}
return 0;
err_to_dev_reg:
mutex_destroy(&vibdata.lock);
wake_lock_destroy(&vibdata.wklock);
pwm_free(vibdata.pwm_dev);
err_pwm_req:
gpio_free(GPIO_VIBTONE_EN1);
return ret;
}
static int mdss_edp_pwm_config(struct mdss_edp_drv_pdata *edp_drv)
{
int ret = 0;
ret = of_property_read_u32(edp_drv->pdev->dev.of_node,
"qcom,panel-pwm-period", &edp_drv->pwm_period);
if (ret) {
pr_err("%s: panel pwm period is not specified, %d", __func__,
edp_drv->pwm_period);
return -EINVAL;
}
ret = of_property_read_u32(edp_drv->pdev->dev.of_node,
"qcom,panel-lpg-channel", &edp_drv->lpg_channel);
if (ret) {
pr_err("%s: panel lpg channel is not specified, %d", __func__,
edp_drv->lpg_channel);
return -EINVAL;
}
edp_drv->bl_pwm = pwm_request(edp_drv->lpg_channel, "lcd-backlight");
if (edp_drv->bl_pwm == NULL || IS_ERR(edp_drv->bl_pwm)) {
pr_err("%s: pwm request failed", __func__);
edp_drv->bl_pwm = NULL;
return -EIO;
}
edp_drv->gpio_panel_pwm = of_get_named_gpio(edp_drv->pdev->dev.of_node,
"gpio-panel-pwm", 0);
if (!gpio_is_valid(edp_drv->gpio_panel_pwm)) {
pr_err("%s: gpio_panel_pwm=%d not specified\n", __func__,
edp_drv->gpio_panel_pwm);
goto edp_free_pwm;
}
ret = gpio_request(edp_drv->gpio_panel_pwm, "disp_pwm");
if (ret) {
pr_err("%s: Request reset gpio_panel_pwm failed, ret=%d\n",
__func__, ret);
goto edp_free_pwm;
}
return 0;
edp_free_pwm:
pwm_free(edp_drv->bl_pwm);
return -ENODEV;
}
static int pwm_fan_remove(struct platform_device *pdev)
{
struct fan_dev_data *fan_data = platform_get_drvdata(pdev);
if (!fan_data)
return -EINVAL;
debugfs_remove_recursive(fan_debugfs_root);
free_irq(fan_data->tach_irq, NULL);
gpio_free(fan_data->tach_gpio);
pwm_config(fan_data->pwm_dev, 0, fan_data->pwm_period);
pwm_disable(fan_data->pwm_dev);
pwm_free(fan_data->pwm_dev);
thermal_cooling_device_unregister(fan_data->cdev);
remove_sysfs_entry(&pdev->dev);
return 0;
}
int OSAL_Pwm_free(__hdle p_handler)
{
int ret = 0;
struct pwm_device *pwm_dev;
pwm_dev = (struct pwm_device *)p_handler;
if(NULL == pwm_dev || IS_ERR(pwm_dev)) {
__wrn("OSAL_Pwm_free, handle is NULL!\n");
ret = -1;
} else {
pwm_free(pwm_dev);
__inf("OSAL_Pwm_free pwm %d \n", pwm_dev->pwm);
}
return ret;
}
static int mars_pwm_buzzer_remove(struct platform_device *pdev)
{
struct platform_pwm_buzzer_data *data = pdev->dev.platform_data;
//struct mars_pwm_buzzer_data *pb = dev_get_drvdata(&pdev->dev);
misc_deregister(&mars_buzzer_pwm_misc_dev);
pwm_config(pb->pwm, 0, pb->period);
pwm_disable(pb->pwm);
pwm_free(pb->pwm);
kfree(pb);
if (data->exit)
data->exit(&pdev->dev);
printk("%s is moving away!\n", __FUNCTION__);
return 0;
}
static int __devexit isa1200_remove(struct i2c_client *client)
{
struct isa1200_chip *haptic = i2c_get_clientdata(client);
cancel_work_sync(&haptic->work);
hrtimer_cancel(&haptic->timer);
timed_output_dev_unregister(&haptic->dev);
gpio_free(haptic->pdata->hap_en_gpio);
if (haptic->pdata->power_on)
haptic->pdata->power_on(0);
pwm_free(haptic->pwm);
kfree(haptic);
return 0;
}
static int qpnp_vibrator_config(struct qpnp_vib *vib)
{
u8 reg = 0;
int rc;
/* Configure the VTG CTL regiser */
rc = qpnp_vib_read_u8(vib, ®, QPNP_VIB_VTG_CTL(vib->base));
if (rc < 0)
return rc;
reg &= ~QPNP_VIB_VTG_SET_MASK;
reg |= (vib->vtg_level & QPNP_VIB_VTG_SET_MASK);
rc = qpnp_vib_write_u8(vib, ®, QPNP_VIB_VTG_CTL(vib->base));
if (rc)
return rc;
vib->reg_vtg_ctl = reg;
/* Configure the VIB ENABLE regiser */
rc = qpnp_vib_read_u8(vib, ®, QPNP_VIB_EN_CTL(vib->base));
if (rc < 0)
return rc;
reg |= (!!vib->active_low) << QPNP_VIB_LOGIC_SHIFT;
if (vib->mode != QPNP_VIB_MANUAL) {
vib->pwm_info.pwm_dev = pwm_request(vib->pwm_info.pwm_channel,
"qpnp-vib");
if (IS_ERR_OR_NULL(vib->pwm_info.pwm_dev)) {
dev_err(&vib->spmi->dev, "vib pwm request failed\n");
return -ENODEV;
}
rc = pwm_config(vib->pwm_info.pwm_dev, vib->pwm_info.duty_us,
vib->pwm_info.period_us);
if (rc < 0) {
dev_err(&vib->spmi->dev, "vib pwm config failed\n");
pwm_free(vib->pwm_info.pwm_dev);
return -ENODEV;
}
reg |= BIT(vib->mode - 1);
}
rc = qpnp_vib_write_u8(vib, ®, QPNP_VIB_EN_CTL(vib->base));
if (rc < 0)
return rc;
vib->reg_en_ctl = reg;
return rc;
}
