自学教程：C++ spi_get_drvdata函数代码示例

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