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