/* fixme, confirm ordering in this function */
static int adis16080_remove(struct spi_device *spi)
{
iio_device_unregister(spi_get_drvdata(spi));
iio_device_free(spi_get_drvdata(spi));
return 0;
}
static int __devexit ad9850_remove(struct spi_device *spi)
{
iio_device_unregister(spi_get_drvdata(spi));
iio_free_device(spi_get_drvdata(spi));
return 0;
}
static int st_magn_spi_remove(struct spi_device *spi)
{
struct iio_dev *indio_dev = spi_get_drvdata(spi);
st_magn_common_remove(indio_dev);
return 0;
}
static int bma220_resume(struct device *dev)
{
struct bma220_data *data =
iio_priv(spi_get_drvdata(to_spi_device(dev)));
return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND);
}
static int __devexit lis302dl_spi_remove(struct spi_device *spi)
{
struct lis3lv02d *lis3 = spi_get_drvdata(spi);
lis3lv02d_joystick_disable();
lis3lv02d_poweroff(lis3);
return 0;
}
static int
ifx_spi_remove(struct spi_device *spi)
{
struct ifx_spi_data *spi_data;
spi_data = spi_get_drvdata(spi);
// WBT DEFECT FIX [email protected]
if(spi_data == NULL){
return 0;
}
// WBT DEFECT FIX [email protected]
spin_lock_irq(&spi_data->spi_lock);
spi_data->spi = NULL;
spi_set_drvdata(spi, NULL);
spin_unlock_irq(&spi_data->spi_lock);
if(ifx_tx_buffer){
kfree(ifx_tx_buffer);
}
if(ifx_rx_buffer){
kfree(ifx_rx_buffer);
}
if(spi_data){
kfree(spi_data);
}
return 0;
}
static int st33zp24_spi_request_resources(struct spi_device *dev)
{
struct tpm_chip *chip = spi_get_drvdata(dev);
struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
struct st33zp24_spi_phy *phy = tpm_dev->phy_id;
struct st33zp24_platform_data *pdata;
int ret;
pdata = dev->dev.platform_data;
if (!pdata) {
dev_err(&dev->dev, "No platform data\n");
return -ENODEV;
}
/* store for late use */
phy->io_lpcpd = pdata->io_lpcpd;
if (gpio_is_valid(pdata->io_lpcpd)) {
ret = devm_gpio_request_one(&dev->dev,
pdata->io_lpcpd, GPIOF_OUT_INIT_HIGH,
"TPM IO_LPCPD");
if (ret) {
dev_err(&dev->dev, "%s : reset gpio_request failed\n",
__FILE__);
return ret;
}
}
return 0;
}
static int __devexit wm8988_spi_remove(struct spi_device *spi)
{
struct wm8988_priv *wm8988 = spi_get_drvdata(spi);
snd_soc_unregister_codec(&spi->dev);
regmap_exit(wm8988->regmap);
return 0;
}
static ssize_t bu21150_wake_up_enable_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
struct bu21150_data *ts = spi_get_drvdata(g_client_bu21150);
return snprintf(buf, PAGE_SIZE, "%u", ts->wake_up);
}
static ssize_t bu21150_wake_up_enable_store(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf, size_t count)
{
struct bu21150_data *ts = spi_get_drvdata(g_client_bu21150);
unsigned long state;
ssize_t ret;
ret = kstrtoul(buf, 10, &state);
if (ret)
return ret;
if (!!state == ts->wake_up)
return count;
mutex_lock(&ts->mutex_wake);
if (state == 0) {
disable_irq_wake(ts->client->irq);
device_init_wakeup(&ts->client->dev, false);
ts->wake_up = false;
} else {
device_init_wakeup(&ts->client->dev, true);
enable_irq_wake(ts->client->irq);
ts->wake_up = true;
}
mutex_unlock(&ts->mutex_wake);
return count;
}
static long bu21150_ioctl_set_timeout(unsigned long arg)
{
struct bu21150_data *ts = spi_get_drvdata(g_client_bu21150);
void __user *argp = (void __user *)arg;
struct bu21150_ioctl_timeout_data data;
if (!ts->timeout_enable)
return 0;
if (copy_from_user(&data, argp,
sizeof(struct bu21150_ioctl_timeout_data))) {
pr_err("%s: Failed to copy_from_user().\n", __func__);
return -EFAULT;
}
ts->timeout_enb = data.timeout_enb;
if (data.timeout_enb == 1) {
ts->timeout = (unsigned int)(data.report_interval_us
* TIMEOUT_SCALE * HZ / 1000000);
} else {
get_frame_timer_delete();
}
return 0;
}
static long bu21150_ioctl_spi_write(unsigned long arg)
{
struct bu21150_data *ts = spi_get_drvdata(g_client_bu21150);
void __user *argp = (void __user *)arg;
struct bu21150_ioctl_spi_data data;
if (arg == 0) {
pr_err("%s: arg == 0.\n", __func__);
return -EINVAL;
}
if (copy_from_user(&data, argp,
sizeof(struct bu21150_ioctl_spi_data))) {
pr_err("%s: Failed to copy_from_user().\n", __func__);
return -EFAULT;
}
if (data.buf == 0 || data.count == 0 ||
MAX_FRAME_SIZE < data.count) {
pr_err("%s: data.buf == 0 ...\n", __func__);
return -EINVAL;
}
if (copy_from_user(ts->spi_buf, data.buf, data.count)) {
pr_err("%s: Failed to copy_from_user()..\n", __func__);
return -EFAULT;
}
bu21150_write_register(data.addr, data.count, ts->spi_buf);
return 0;
}
static int spi_aic3008_remove(struct spi_device *spi_aic3008)
{
AUD_DBG("Remove the SPI driver for aic3008.\n");
snd_soc_unregister_codec(&spi_aic3008->dev);
kfree(spi_get_drvdata(spi_aic3008));
return 0;
}
struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev,
struct spi_master *master, struct spi_board_info *info)
{
struct v4l2_subdev *sd = NULL;
struct spi_device *spi = NULL;
BUG_ON(!v4l2_dev);
if (info->modalias)
request_module(info->modalias);
spi = spi_new_device(master, info);
if (spi == NULL || spi->dev.driver == NULL)
goto error;
if (!try_module_get(spi->dev.driver->owner))
goto error;
sd = spi_get_drvdata(spi);
if (v4l2_device_register_subdev(v4l2_dev, sd))
sd = NULL;
module_put(spi->dev.driver->owner);
error:
if (spi && sd == NULL)
spi_unregister_device(spi);
return sd;
}
static int hx8357_remove(struct spi_device *spi)
{
struct lcd_device *lcdev = spi_get_drvdata(spi);
lcd_device_unregister(lcdev);
return 0;
}
static void ssp_shutdown(struct spi_device *spi)
{
struct ssp_data *data = spi_get_drvdata(spi);
pr_err("[SSP] %s, data->fw_dl_state[%d]*******************!\n",
__func__,data->fw_dl_state);
pr_err("[SSP] lpm %d recovery \n",lpcharge /*, recovery_mode*/);
func_dbg();
if (data->bProbeIsDone == false)
goto exit;
disable_debug_timer(data);
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
pr_err("[SSP] %s, cancel_delayed_work_sync state = %d\n",
__func__, data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SHUTDOWN, 0))
pr_err("[SSP]: %s MSG2SSP_AP_STATUS_SHUTDOWN failed\n",
__func__);
ssp_enable(data, false);
clean_pending_list(data);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
free_irq(data->iIrq, data);
gpio_free(data->mcu_int1);
remove_event_symlink(data);
remove_sysfs(data);
remove_input_dev(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_sensorhub_remove(data);
#endif
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
cancel_delayed_work_sync(&data->work_refresh);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_destroy(&data->bulk_temp_read_lock);
mutex_destroy(&data->cp_temp_adc_lock);
#endif
#ifdef CONFIG_SENSORS_SSP_ATMEL
mutex_destroy(&data->comm_mutex);
mutex_destroy(&data->pending_mutex);
#endif
toggle_mcu_reset(data);
pr_info("[SSP] %s done\n", __func__);
exit:
kfree(data);
}
static int itdb28fb_remove_spi(struct spi_device *spi)
{
struct fb_info *info = spi_get_drvdata(spi);
fbtft_dev_dbg(DEBUG_DRIVER_INIT_FUNCTIONS, &spi->dev, "%s()\n", __func__);
return itdb28fb_remove_common(&spi->dev, info);
}
static int st33zp24_spi_acpi_request_resources(struct spi_device *spi_dev)
{
struct tpm_chip *chip = spi_get_drvdata(spi_dev);
struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
struct st33zp24_spi_phy *phy = tpm_dev->phy_id;
struct gpio_desc *gpiod_lpcpd;
struct device *dev = &spi_dev->dev;
int ret;
ret = acpi_dev_add_driver_gpios(ACPI_COMPANION(dev), acpi_st33zp24_gpios);
if (ret)
return ret;
/* Get LPCPD GPIO from ACPI */
gpiod_lpcpd = devm_gpiod_get(dev, "lpcpd", GPIOD_OUT_HIGH);
if (IS_ERR(gpiod_lpcpd)) {
dev_err(dev, "Failed to retrieve lpcpd-gpios from acpi.\n");
phy->io_lpcpd = -1;
/*
* lpcpd pin is not specified. This is not an issue as
* power management can be also managed by TPM specific
* commands. So leave with a success status code.
*/
return 0;
}
phy->io_lpcpd = desc_to_gpio(gpiod_lpcpd);
return 0;
}
static int __devexit ds3234_remove(struct spi_device *spi)
{
struct rtc_device *rtc = spi_get_drvdata(spi);
rtc_device_unregister(rtc);
return 0;
}
static int __devexit ak4104_spi_remove(struct spi_device *spi)
{
struct ak4104_private *ak4101 = spi_get_drvdata(spi);
regmap_exit(ak4101->regmap);
snd_soc_unregister_codec(&spi->dev);
return 0;
}
static int st_nci_spi_request_resources(struct spi_device *dev)
{
struct st_nci_nfc_platform_data *pdata;
struct st_nci_spi_phy *phy = spi_get_drvdata(dev);
int r;
pdata = dev->dev.platform_data;
if (pdata == NULL) {
nfc_err(&dev->dev, "No platform data\n");
return -EINVAL;
}
/* store for later use */
phy->gpio_reset = pdata->gpio_reset;
phy->irq_polarity = pdata->irq_polarity;
r = devm_gpio_request_one(&dev->dev,
phy->gpio_reset, GPIOF_OUT_INIT_HIGH, "clf_reset");
if (r) {
pr_err("%s : reset gpio_request failed\n", __FILE__);
return r;
}
phy->se_status.is_ese_present = pdata->is_ese_present;
phy->se_status.is_uicc_present = pdata->is_uicc_present;
return 0;
}
static int da9052_spi_remove(struct spi_device *spi)
{
struct da9052 *da9052 = spi_get_drvdata(spi);
da9052_device_exit(da9052);
return 0;
}
static int32_t msm_eeprom_spi_remove(struct spi_device *sdev)
{
struct v4l2_subdev *sd = spi_get_drvdata(sdev);
struct msm_eeprom_ctrl_t *e_ctrl;
if (!sd) {
pr_err("%s: Subdevice is NULL\n", __func__);
return 0;
}
e_ctrl = (struct msm_eeprom_ctrl_t *)v4l2_get_subdevdata(sd);
if (!e_ctrl) {
pr_err("%s: eeprom device is NULL\n", __func__);
return 0;
}
kfree(e_ctrl->i2c_client.spi_client);
kfree(e_ctrl->memory_data);
if (e_ctrl->eboard_info) {
kfree(e_ctrl->eboard_info->power_info.gpio_conf);
kfree(e_ctrl->eboard_info->eeprom_map);
}
kfree(e_ctrl->eboard_info);
kfree(e_ctrl);
return 0;
}
static int rtw_gspi_resume(struct spi_device *spi)
{
struct dvobj_priv *dvobj = spi_get_drvdata(spi);
PADAPTER padapter = dvobj->if1;
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
int ret = 0;
DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
if(pwrpriv->bInternalAutoSuspend ){
ret = rtw_resume_process(padapter);
} else {
#ifdef CONFIG_RESUME_IN_WORKQUEUE
rtw_resume_in_workqueue(pwrpriv);
#elif defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
if(rtw_is_earlysuspend_registered(pwrpriv)) {
//jeff: bypass resume here, do in late_resume
pwrpriv->do_late_resume = _TRUE;
} else {
ret = rtw_resume_process(padapter);
}
#else // Normal resume process
ret = rtw_resume_process(padapter);
#endif //CONFIG_RESUME_IN_WORKQUEUE
}
DBG_871X("<======== %s return %d\n", __FUNCTION__, ret);
return ret;
}
static int m10mo_spi_remove(struct spi_device *spi)
{
struct m10mo_spi *m10mo_spi_dev;
m10mo_spi_dev = spi_get_drvdata(spi);
kfree(m10mo_spi_dev);
return 0;
}
static int rtw_gspi_resume(struct spi_device *spi)
{
struct dvobj_priv *dvobj = spi_get_drvdata(spi);
PADAPTER padapter = dvobj->if1;
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
int ret = 0;
DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
if(pwrpriv->bInternalAutoSuspend ){
ret = rtw_resume_process(padapter);
} else {
#ifdef CONFIG_RESUME_IN_WORKQUEUE
rtw_resume_in_workqueue(pwrpriv);
#else
if(rtw_is_earlysuspend_registered(pwrpriv)) {
/* jeff: bypass resume here, do in late_resume */
rtw_set_do_late_resume(pwrpriv, _TRUE);
} else {
ret = rtw_resume_process(padapter);
}
#endif /* CONFIG_RESUME_IN_WORKQUEUE */
}
DBG_871X("<======== %s return %d\n", __FUNCTION__, ret);
return ret;
}
static int wl1271_remove(struct spi_device *spi)
{
struct wl12xx_spi_glue *glue = spi_get_drvdata(spi);
platform_device_unregister(glue->core);
return 0;
}
static int tps65912_spi_remove(struct spi_device *spi)
{
struct tps65912 *tps65912 = spi_get_drvdata(spi);
tps65912_device_exit(tps65912);
return 0;
}
static int __devexit cyttsp_spi_remove(struct spi_device *spi)
{
struct cyttsp *ts = spi_get_drvdata(spi);
cyttsp_remove(ts);
return 0;
}
static int __devexit ad193x_spi_remove(struct spi_device *spi)
{
struct ad193x_priv *ad193x = spi_get_drvdata(spi);
snd_soc_unregister_codec(&spi->dev);
regmap_exit(ad193x->regmap);
return 0;
}