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; }