static int alsa_to_h2w_remove(struct platform_device *pdev)
{
struct alsa_to_h2w_data *switch_data = platform_get_drvdata(pdev);
switch_dev_unregister(&switch_data->sdev);
kfree(switch_data);
headset_switch_data = NULL;
return 0;
}
static int __devexit hs_remove(struct platform_device *pdev)
{
struct msm_handset *hs = platform_get_drvdata(pdev);
input_unregister_device(hs->ipdev);
switch_dev_unregister(&hs->sdev);
kfree(hs);
hs_rpc_deinit();
return 0;
}
int acer_hs_butt_remove(void)
{
input_unregister_device(hr->input);
gpio_free(hr->butt);
free_irq(hr->irq, 0);
switch_dev_unregister(&hr->sdev);
return 0;
}
static int max98090_i2c_remove(struct i2c_client *client)
{
struct snd_soc_codec *codec = i2c_get_clientdata(client);
#if defined(CONFIG_MAX98090_HEADSET)
switch_dev_unregister(&switch_jack_detection);
#endif
kfree(codec->reg_cache);
return 0;
}
void tegra_jack_exit(void)
{
switch_dev_unregister(&wired_switch_dev);
platform_driver_unregister(&tegra_wired_jack_driver);
if (tegra_wired_jack) {
kfree(tegra_wired_jack);
tegra_wired_jack = 0;
}
}
static int __devexit sh_hs_remove(struct platform_device *pdev)
{
struct msm_handset *hssw_data = platform_get_drvdata(pdev);
input_unregister_device(hssw_data->ipdev);
switch_dev_unregister(&hssw_data->sdev_hssw);
kfree(hssw_data);
return 0;
}
static int __devexit pm8xxx_cradle_remove(struct platform_device *pdev)
{
struct pm8xxx_cradle *cradle = platform_get_drvdata(pdev);
cancel_delayed_work_sync(&cradle->pouch_work);
switch_dev_unregister(&cradle->sdev);
platform_set_drvdata(pdev, NULL);
kfree(cradle);
return 0;
}
static int __devexit dock_switch_remove(struct platform_device *pdev)
{
struct dock_switch_data *switch_data = platform_get_drvdata(pdev);
cancel_work_sync(&switch_data->work);
switch_dev_unregister(&switch_data->sdev);
kfree(switch_data);
return 0;
}
static int htc_headset_mgr_remove(struct platform_device *pdev)
{
#if 0
if ((switch_get_state(&hi->sdev_h2w) & MASK_HEADSET) != 0)
remove_headset();
#endif
unregister_attributes();
input_unregister_device(hi->input);
destroy_workqueue(button_wq);
destroy_workqueue(detect_wq);
switch_dev_unregister(&hi->sdev_usb_audio);
switch_dev_unregister(&hi->sdev_h2w);
mutex_destroy(&hi->mutex_lock);
wake_lock_destroy(&hi->hs_wake_lock);
kfree(hi);
return 0;
}
static int acer_hs_remove(struct platform_device *pdev)
{
ACER_HS_DBG("");
if (switch_get_state(&hr->sdev))
remove_headset();
gpio_free(hr->det);
free_irq(hr->irq, 0);
switch_dev_unregister(&hr->sdev);
return 0;
}
static int tristate_dev_remove(struct platform_device *pdev)
{
printk("%s\n",__func__);
cancel_work_sync(&switch_data->work);
gpio_free(switch_data->key1_gpio);
gpio_free(switch_data->key2_gpio);
switch_dev_unregister(&switch_data->sdev);
kfree(switch_data);
return 0;
}
static int __devexit hs_remove(struct platform_device *pdev)
{
struct msm_handset *hs = platform_get_drvdata(pdev);
cancel_delayed_work_sync(&pwrkey_work);
destroy_workqueue(pwrkey_wqueue);
input_unregister_device(hs->ipdev);
switch_dev_unregister(&hs->sdev);
kfree(hs);
hs_rpc_deinit();
return 0;
}
static int htc_35mm_remove(struct platform_device *pdev)
{
H2W_DBG("");
switch_dev_unregister(&hi->hs_change);
kzfree(hi);
#if 0 /* Add keys later */
input_unregister_device(hi->input);
#endif
return 0;
}
static int h2w_remove(struct platform_device *pdev)
{
/* yl_debug(""); */
if (switch_get_state(&hi->sdev))
remove_headset();
input_unregister_device(hi->input);
switch_dev_unregister(&hi->sdev);
kfree(hi);
return 0;
}
static int max97236_i2c_remove(struct i2c_client *client)
{
struct max97236_priv *max97236 = dev_get_drvdata(&client->dev);
snd_soc_unregister_codec(&client->dev);
regmap_exit(max97236->regmap);
kfree(i2c_get_clientdata(client));
#ifdef CONFIG_SWITCH
switch_dev_unregister(&tegra_max97236_button_switch);
#endif
return 0;
}
static int aml_m3_audio_remove(struct platform_device *pdev)
{
printk("***Entered %s:%s\n", __FILE__,__func__);
#if HP_DET
del_timer_sync(&timer);
switch_dev_unregister(&sdev);
#endif
platform_device_unregister(aml_m3_snd_device);
return 0;
}
static int __devexit psensor_remove(struct platform_device *pdev)
{
struct psensor_data *psensor = platform_get_drvdata(pdev);
cancel_work_sync(&psensor->work);
gpio_free(psensor->gpio);
switch_dev_unregister(&psensor->sdev);
kfree(psensor);
return 0;
}
static int acc_con_probe(struct platform_device *pdev)
{
struct acc_con_info *acc;
struct acc_con_platform_data *pdata = pdev->dev.platform_data;
int retval;
ACC_CONDEV_DBG("");
if (pdata == NULL) {
pr_err("%s: no pdata\n", __func__);
return -ENODEV;
}
acc = kzalloc(sizeof(*acc), GFP_KERNEL);
if (!acc)
return -ENOMEM;
acc->pdata = pdata;
acc->current_dock = DOCK_NONE;
acc->current_accessory = ACCESSORY_NONE;
mutex_init(&acc->lock);
retval = dev_set_drvdata(&pdev->dev, acc);
if (retval < 0)
goto err_sw_dock;
acc->acc_dev = &pdev->dev;
acc->dock_switch.name = "dock";
retval = switch_dev_register(&acc->dock_switch);
if (retval < 0)
goto err_sw_dock;
acc->ear_jack_switch.name = "usb_audio";
retval = switch_dev_register(&acc->ear_jack_switch);
if (retval < 0)
goto err_sw_jack;
wake_lock_init(&acc->wake_lock, WAKE_LOCK_SUSPEND, "30pin_con");
INIT_DELAYED_WORK(&acc->acc_dwork, acc_delay_work);
schedule_delayed_work(&acc->acc_dwork, msecs_to_jiffies(24000));
INIT_DELAYED_WORK(&acc->acc_id_dwork, acc_id_delay_work);
return 0;
err_sw_jack:
switch_dev_unregister(&acc->dock_switch);
err_sw_dock:
kfree(acc);
return retval;
}
static int stml0xx_remove(struct spi_device *spi)
{
struct stml0xx_data *ps_stml0xx = spi_get_drvdata(spi);
switch_dev_unregister(&ps_stml0xx->dsdev);
switch_dev_unregister(&ps_stml0xx->edsdev);
if (ps_stml0xx->irq_wake != -1)
free_irq(ps_stml0xx->irq_wake, ps_stml0xx);
free_irq(ps_stml0xx->irq, ps_stml0xx);
misc_deregister(&stml0xx_misc_device);
input_unregister_device(ps_stml0xx->input_dev);
input_free_device(ps_stml0xx->input_dev);
stml0xx_device_power_off(ps_stml0xx);
if (ps_stml0xx->pdata->exit)
ps_stml0xx->pdata->exit();
stml0xx_gpio_free(ps_stml0xx->pdata);
destroy_workqueue(ps_stml0xx->irq_work_queue);
mutex_destroy(&ps_stml0xx->lock);
wake_unlock(&ps_stml0xx->wakelock);
wake_lock_destroy(&ps_stml0xx->wakelock);
wake_unlock(&ps_stml0xx->wake_sensor_wakelock);
wake_lock_destroy(&ps_stml0xx->wake_sensor_wakelock);
wake_unlock(&ps_stml0xx->reset_wakelock);
wake_lock_destroy(&ps_stml0xx->reset_wakelock);
disable_irq_wake(ps_stml0xx->irq);
if (!IS_ERR(ps_stml0xx->regulator_3)) {
regulator_disable(ps_stml0xx->regulator_3);
regulator_put(ps_stml0xx->regulator_3);
}
regulator_disable(ps_stml0xx->regulator_2);
regulator_disable(ps_stml0xx->regulator_1);
regulator_put(ps_stml0xx->regulator_2);
regulator_put(ps_stml0xx->regulator_1);
return 0;
}
int hs_unregsysfs(struct mic_t *p)
{
int result = 0;
#ifdef CONFIG_SWITCH
result = cancel_delayed_work_sync(&p->switch_data.work);
if (result != 0) {
return result;
}
switch_dev_unregister(&p->switch_data.sdev);
#endif
return 0;
}
static int headset_remove(struct platform_device *pdev)
{
input_unregister_device(headset_data.input);
free_irq(headset_data.hook_irq, 0);
free_irq(headset_data.jack_irq, 0);
destroy_workqueue(g_detection_work_queue);
switch_dev_unregister(&headset_data.sdev);
return 0;
}
static int acc_con_remove(struct platform_device *pdev)
{
struct acc_con_info *acc = platform_get_drvdata(pdev);
ACC_CONDEV_DBG("");
free_irq(acc->accessory_irq, acc);
free_irq(acc->dock_irq, acc);
#ifdef CONFIG_MHL_SII9234
i2c_del_driver(&SII9234A_i2c_driver);
i2c_del_driver(&SII9234B_i2c_driver);
i2c_del_driver(&SII9234C_i2c_driver);
i2c_del_driver(&SII9234_i2c_driver);
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
cancel_delayed_work_sync(&acc->acc_con_work);
#endif
switch_dev_unregister(&acc->dock_switch);
switch_dev_unregister(&acc->ear_jack_switch);
kfree(acc);
return 0;
}
static int __devexit hs_remove(struct platform_device *pdev)
{
struct msm_handset *hs = platform_get_drvdata(pdev);
input_unregister_device(hs->ipdev);
#ifdef CONFIG_MACH_MSM7X27_UNIVA
switch_dev_unregister(&hs->sdev);
#endif
kfree(hs);
hs_rpc_deinit();
return 0;
}
static int sec_jack_remove(struct platform_device *pdev)
{
struct sec_jack_info *hi = dev_get_drvdata(&pdev->dev);
pr_info(MODULE_NAME "%s :\n", __func__);
/* rebalance before free */
if (hi->send_key_irq_enabled)
disable_irq_wake(hi->pdata->send_int);
else
enable_irq(hi->pdata->send_int);
free_irq(hi->pdata->send_int, hi);
disable_irq_wake(hi->pdata->det_int);
free_irq(hi->pdata->det_int, hi);
wake_lock_destroy(&hi->det_wake_lock);
switch_dev_unregister(&switch_jack_detection);
switch_dev_unregister(&switch_sendend);
input_unregister_device(hi->input);
kfree(hi);
return 0;
}
static int __devexit hall_sensor_remove(struct platform_device *pdev)
{
struct ak_hall_data *hl = platform_get_drvdata(pdev);
if (hl->input_dev) {
input_unregister_device(hl->input_dev);
input_free_device(hl->input_dev);
}
switch_dev_unregister(&cover_switch);
wake_lock_destroy(&hl->wake_lock);
kfree(g_hl);
return 0;
}
static int vga_edid_remove(struct i2c_client *client)
{
if(ddev->edid)
kfree(ddev->edid);
if (ddev->specs.modedb)
kfree(ddev->specs.modedb);
kfree(ddev);
#ifdef CONFIG_SWITCH
switch_dev_unregister(&(ddev->switchdev));
//kfree(ddev->switchdev.name);
#endif
return 0;
}
// Remove Driver
static int __devexit pantech_earjack_remove(struct platform_device *pdev)
{
struct pantech_earjack *earjack = platform_get_drvdata(pdev);
dbg_func_in();
input_unregister_device(earjack->ipdev);
switch_dev_unregister(&earjack->sdev);
kfree(earjack);
wake_lock_destroy(&earjack_wake_lock);
wake_lock_destroy(&remotekey_wake_lock);
dbg_func_out();
return 0;
}
static int __devexit hs_remove(struct platform_device *pdev)
{
struct msm_handset *hs = platform_get_drvdata(pdev);
input_unregister_device(hs->ipdev);
switch_dev_unregister(&hs->sdev);
kfree(hs);
hs_rpc_deinit();
#ifdef CONFIG_FEATURE_KCC_F45
g_init_flag = false;
#endif
return 0;
}
/**********************************************************
** Function: Headset driver exit function
** Parameter: none
** Return value: none
**
************************************************************/
static void __exit headset_exit(void)
{
printk("HEADSET: Headset exit\n");
if (switch_get_state(&hs_data->sdev))
remove_headset();
gpio_free(JACK_GPIO);
gpio_free(HOOK_GPIO);
gpio_free(LINEOUT_GPIO);
free_irq(hs_data->irq, 0);
destroy_workqueue(g_detection_work_queue);
switch_dev_unregister(&hs_data->sdev);
}
int mdp_close(struct v4l2_subdev *sd, void *arg)
{
struct mdp_instance *inst = arg;
struct fb_info *fbi = NULL;
if (inst) {
fbi = (struct fb_info *)inst->mdp;
msm_fb_writeback_terminate(fbi);
kfree(inst);
/* Unregister wfd node from switch driver */
switch_dev_unregister(&inst->sdev);
}
return 0;
}
