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

static int adis16400_probe(struct spi_device *spi){	struct adis16400_state *st;	struct iio_dev *indio_dev;	int ret;	indio_dev = iio_device_alloc(sizeof(*st));	if (indio_dev == NULL)		return -ENOMEM;	st = iio_priv(indio_dev);	/* this is only used for removal purposes */	spi_set_drvdata(spi, indio_dev);	/* setup the industrialio driver allocated elements */	st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data];	indio_dev->dev.parent = &spi->dev;	indio_dev->name = spi_get_device_id(spi)->name;	indio_dev->channels = st->variant->channels;	indio_dev->num_channels = st->variant->num_channels;	indio_dev->info = &adis16400_info;	indio_dev->modes = INDIO_DIRECT_MODE;	if (!(st->variant->flags & ADIS16400_NO_BURST))		indio_dev->available_scan_masks = adis16400_burst_scan_mask;	ret = adis_init(&st->adis, indio_dev, spi, &adis16400_data);	if (ret)		goto error_free_dev;	ret = adis_setup_buffer_and_trigger(&st->adis, indio_dev,			adis16400_trigger_handler);	if (ret)		goto error_free_dev;	/* Get the device into a sane initial state */	ret = adis16400_initial_setup(indio_dev);	if (ret)		goto error_cleanup_buffer;	ret = iio_device_register(indio_dev);	if (ret)		goto error_cleanup_buffer;	adis16400_debugfs_init(indio_dev);	return 0;error_cleanup_buffer:	adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);error_free_dev:	iio_device_free(indio_dev);	return ret;}

static int ak4104_spi_probe(struct spi_device *spi){	struct ak4104_private *ak4104;	struct gpio_desc *reset_gpiod;	unsigned int val;	int ret;	spi->bits_per_word = 8;	spi->mode = SPI_MODE_0;	ret = spi_setup(spi);	if (ret < 0)		return ret;	ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private),			      GFP_KERNEL);	if (ak4104 == NULL)		return -ENOMEM;	ak4104->regulator = devm_regulator_get(&spi->dev, "vdd");	if (IS_ERR(ak4104->regulator)) {		ret = PTR_ERR(ak4104->regulator);		dev_err(&spi->dev, "Unable to get Vdd regulator: %d/n", ret);		return ret;	}	ak4104->regmap = devm_regmap_init_spi(spi, &ak4104_regmap);	if (IS_ERR(ak4104->regmap)) {		ret = PTR_ERR(ak4104->regmap);		return ret;	}	reset_gpiod = devm_gpiod_get_optional(&spi->dev, "reset",					      GPIOD_OUT_HIGH);	if (IS_ERR(reset_gpiod) &&	    PTR_ERR(reset_gpiod) == -EPROBE_DEFER)		return -EPROBE_DEFER;	/* read the 'reserved' register - according to the datasheet, it	 * should contain 0x5b. Not a good way to verify the presence of	 * the device, but there is no hardware ID register. */	ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val);	if (ret != 0)		return ret;	if (val != AK4104_RESERVED_VAL)		return -ENODEV;	spi_set_drvdata(spi, ak4104);	ret = devm_snd_soc_register_component(&spi->dev,			&soc_component_device_ak4104, &ak4104_dai, 1);	return ret;}

static int corgi_lcd_probe(struct spi_device *spi){	struct backlight_properties props;	struct corgi_lcd_platform_data *pdata = dev_get_platdata(&spi->dev);	struct corgi_lcd *lcd;	int ret = 0;	if (pdata == NULL) {		dev_err(&spi->dev, "platform data not available/n");		return -EINVAL;	}	lcd = devm_kzalloc(&spi->dev, sizeof(struct corgi_lcd), GFP_KERNEL);	if (!lcd)		return -ENOMEM;	lcd->spi_dev = spi;	lcd->lcd_dev = devm_lcd_device_register(&spi->dev, "corgi_lcd",						&spi->dev, lcd, &corgi_lcd_ops);	if (IS_ERR(lcd->lcd_dev))		return PTR_ERR(lcd->lcd_dev);	lcd->power = FB_BLANK_POWERDOWN;	lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA;	memset(&props, 0, sizeof(struct backlight_properties));	props.type = BACKLIGHT_RAW;	props.max_brightness = pdata->max_intensity;	lcd->bl_dev = devm_backlight_device_register(&spi->dev, "corgi_bl",						&spi->dev, lcd, &corgi_bl_ops,						&props);	if (IS_ERR(lcd->bl_dev))		return PTR_ERR(lcd->bl_dev);	lcd->bl_dev->props.brightness = pdata->default_intensity;	lcd->bl_dev->props.power = FB_BLANK_UNBLANK;	ret = setup_gpio_backlight(lcd, pdata);	if (ret)		return ret;	lcd->kick_battery = pdata->kick_battery;	spi_set_drvdata(spi, lcd);	corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK);	backlight_update_status(lcd->bl_dev);	lcd->limit_mask = pdata->limit_mask;	the_corgi_lcd = lcd;	return 0;}

static int __devinit pmic_probe(struct spi_device *spi){	struct tps6524x *hw;	struct device *dev = &spi->dev;	const struct supply_info *info = supply_info;	struct regulator_init_data *init_data;	int ret = 0, i;	init_data = dev->platform_data;	if (!init_data) {		dev_err(dev, "could not find regulator platform data/n");		return -EINVAL;	}	hw = kzalloc(sizeof(struct tps6524x), GFP_KERNEL);	if (!hw) {		dev_err(dev, "cannot allocate regulator private data/n");		return -ENOMEM;	}	spi_set_drvdata(spi, hw);	memset(hw, 0, sizeof(struct tps6524x));	hw->dev = dev;	hw->spi = spi_dev_get(spi);	mutex_init(&hw->lock);	for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {		hw->desc[i].name	= info->name;		hw->desc[i].id		= i;		hw->desc[i].n_voltages	= info->n_voltages;		hw->desc[i].ops		= &regulator_ops;		hw->desc[i].type	= REGULATOR_VOLTAGE;		hw->desc[i].owner	= THIS_MODULE;		if (info->flags & FIXED_VOLTAGE)			hw->desc[i].n_voltages = 1;		hw->rdev[i] = regulator_register(&hw->desc[i], dev,						 init_data, hw);		if (IS_ERR(hw->rdev[i])) {			ret = PTR_ERR(hw->rdev[i]);			hw->rdev[i] = NULL;			goto fail;		}	}	return 0;fail:	pmic_remove(spi);	return ret;}

void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,		const struct v4l2_subdev_ops *ops){	v4l2_subdev_init(sd, ops);	sd->flags |= V4L2_SUBDEV_FL_IS_SPI;	/* the owner is the same as the spi_device's driver owner */	sd->owner = spi->dev.driver->owner;	/* spi_device and v4l2_subdev point to one another */	v4l2_set_subdevdata(sd, spi);	spi_set_drvdata(spi, sd);	/* initialize name */	strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));}

void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,		const struct v4l2_subdev_ops *ops){	v4l2_subdev_init(sd, ops);	sd->flags |= V4L2_SUBDEV_FL_IS_SPI;		sd->owner = spi->dev.driver->owner;		v4l2_set_subdevdata(sd, spi);	spi_set_drvdata(spi, sd);		strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));}

static int ds3234_probe(struct spi_device *spi){	struct rtc_device *rtc;	unsigned char tmp;	int res;	spi->mode = SPI_MODE_3;	spi->bits_per_word = 8;	spi_setup(spi);	res = ds3234_get_reg(&spi->dev, DS3234_REG_SECONDS, &tmp);	if (res != 0)		return res;	/* Control settings	 *	 * CONTROL_REG	 * BIT 7	6	5	4	3	2	1	0	 *     EOSC	BBSQW	CONV	RS2	RS1	INTCN	A2IE	A1IE	 *	 *     0	0	0	1	1	1	0	0	 *	 * CONTROL_STAT_REG	 * BIT 7	6	5	4	3	2	1	0	 *     OSF	BB32kHz	CRATE1	CRATE0	EN32kHz	BSY	A2F	A1F	 *	 *     1	0	0	0	1	0	0	0	 */	ds3234_get_reg(&spi->dev, DS3234_REG_CONTROL, &tmp);	ds3234_set_reg(&spi->dev, DS3234_REG_CONTROL, tmp & 0x1c);	ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);	ds3234_set_reg(&spi->dev, DS3234_REG_CONT_STAT, tmp & 0x88);	/* Print our settings */	ds3234_get_reg(&spi->dev, DS3234_REG_CONTROL, &tmp);	dev_info(&spi->dev, "Control Reg: 0x%02x/n", tmp);	ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);	dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x/n", tmp);	rtc = devm_rtc_device_register(&spi->dev, "ds3234",				&ds3234_rtc_ops, THIS_MODULE);	if (IS_ERR(rtc))		return PTR_ERR(rtc);	spi_set_drvdata(spi, rtc);	return 0;}

static int __devinit cs4271_spi_probe(struct spi_device *spi){	struct cs4271_private *cs4271;	cs4271 = devm_kzalloc(&spi->dev, sizeof(*cs4271), GFP_KERNEL);	if (!cs4271)		return -ENOMEM;	spi_set_drvdata(spi, cs4271);	cs4271->bus_type = SND_SOC_SPI;	return snd_soc_register_codec(&spi->dev, &soc_codec_dev_cs4271,		&cs4271_dai, 1);}

static int pmic_remove(struct spi_device *spi){	struct tps6524x *hw = spi_get_drvdata(spi);	int i;	if (!hw)		return 0;	for (i = 0; i < N_REGULATORS; i++) {		regulator_unregister(hw->rdev[i]);		hw->rdev[i] = NULL;	}	spi_set_drvdata(spi, NULL);	return 0;}

static void gspi_dvobj_deinit(struct spi_device *spi){	struct dvobj_priv *dvobj = spi_get_drvdata(spi);_func_enter_;	spi_set_drvdata(spi, NULL);	if (dvobj) {		gspi_deinit(dvobj);		rtw_mfree((u8*)dvobj, sizeof(*dvobj));	}_func_exit_;}

static int adis16136_probe(struct spi_device *spi){	const struct spi_device_id *id = spi_get_device_id(spi);	struct adis16136 *adis16136;	struct iio_dev *indio_dev;	int ret;	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adis16136));	if (indio_dev == NULL)		return -ENOMEM;	spi_set_drvdata(spi, indio_dev);	adis16136 = iio_priv(indio_dev);	adis16136->chip_info = &adis16136_chip_info[id->driver_data];	indio_dev->dev.parent = &spi->dev;	indio_dev->name = spi_get_device_id(spi)->name;	indio_dev->channels = adis16136_channels;	indio_dev->num_channels = ARRAY_SIZE(adis16136_channels);	indio_dev->info = &adis16136_info;	indio_dev->modes = INDIO_DIRECT_MODE;	ret = adis_init(&adis16136->adis, indio_dev, spi, &adis16136_data);	if (ret)		return ret;	ret = adis_setup_buffer_and_trigger(&adis16136->adis, indio_dev, NULL);	if (ret)		return ret;	ret = adis16136_initial_setup(indio_dev);	if (ret)		goto error_cleanup_buffer;	ret = iio_device_register(indio_dev);	if (ret)		goto error_stop_device;	adis16136_debugfs_init(indio_dev);	return 0;error_stop_device:	adis16136_stop_device(indio_dev);error_cleanup_buffer:	adis_cleanup_buffer_and_trigger(&adis16136->adis, indio_dev);	return ret;}

static int ad7606_spi_probe(struct spi_device *spi){	struct iio_dev *indio_dev;	indio_dev = ad7606_probe(&spi->dev, spi->irq, NULL,			   spi_get_device_id(spi)->driver_data,			   &ad7606_spi_bops);	if (IS_ERR(indio_dev))		return PTR_ERR(indio_dev);	spi_set_drvdata(spi, indio_dev);	return 0;}

static int __devinit dit4192_spi_probe(struct spi_device *spi){	int ret;	struct dit4192 *chip;	struct dit4192_platform_data *pdata;	if (spi->dev.platform_data == NULL) {		pr_err("%s: platform data is missing/n", __func__);		return -EINVAL;	}	pdata = (struct dit4192_platform_data *)spi->dev.platform_data;        gl_chip = chip = devm_kzalloc(&spi->dev, sizeof(struct dit4192), GFP_KERNEL);        if (!chip)                return -ENOMEM;	pr_info("%s(): /n" , __func__);	chip->spi	= spi;	chip->buf_int	= pdata->gpio_buf_flip_int;	chip->ubit_pin	= pdata->gpio_u_bits;	chip->bls_pin	= pdata->gpio_bls;	chip->reset_pin	= pdata->gpio_reset;        spi_set_drvdata(spi, chip);	ret = dit4192_gpio_init(chip);	if( ret < 0 ) {		return ret;	}	dit4192_poweron(chip);	ret = dit4192_check_device(chip);	if (ret < 0) {		dit4192_gpio_free(chip);		return ret;	}			/* send initial values */	dit4192_init(chip);	ret = snd_soc_register_codec(	&spi->dev,					&soc_codec_dev_dit4192, 					dit4192_dai, 					ARRAY_SIZE(dit4192_dai));	return 0;}

static int __init ab4500_probe(struct spi_device *spi){	struct ab4500	*ab4500;	unsigned char revision;	int err = 0;	int i;	ab4500 = kzalloc(sizeof *ab4500, GFP_KERNEL);	if (!ab4500) {		dev_err(&spi->dev, "could not allocate AB4500/n");		err = -ENOMEM;		goto not_detect;	}	ab4500->spi = spi;	spi_set_drvdata(spi, ab4500);	mutex_init(&ab4500->lock);	/* read the revision register */	revision = ab4500_read(ab4500, AB4500_MISC, AB4500_REV_REG);	/* revision id 0x0 is for early drop, 0x10 is for cut1.0 */	if (revision == 0x0 || revision == 0x10)		dev_info(&spi->dev, "Detected chip: %s, revision = %x/n",			ab4500_driver.driver.name, revision);	else	{		dev_err(&spi->dev, "unknown chip: 0x%x/n", revision);		goto not_detect;	}	for (i = 0; i < ARRAY_SIZE(ab4500_platform_devs); i++)	{		ab4500_platform_devs[i]->dev.parent =			&spi->dev;		platform_set_drvdata(ab4500_platform_devs[i], ab4500);	}	/* register the ab4500 platform devices */	platform_add_devices(ab4500_platform_devs,			ARRAY_SIZE(ab4500_platform_devs));	return err; not_detect:	spi_unregister_driver(&ab4500_driver);	kfree(ab4500);	return err;}

static int nrf905_probe(struct spi_device *spi){	int retval = 0;	dev_info(&spi->dev, "probe/n");	retval = spi_setup(spi);	if (retval < 0) {		dev_err(&spi->dev, "Can not setup spi device/n");		retval = -ENODEV;		goto err;	}	spi_set_drvdata(spi, nrf905_dev);	nrf905_dev->spi_dev = spi;	retval = nrf905_gpio_config(nrf905_dev);	if (retval < 0)		goto err;	retval = devm_request_irq(			nrf905_dev->char_dev,			nrf905_dev->chip.dataready_irq,			nrf905_dr_irq,			IRQF_TRIGGER_RISING,			"nrf905",			nrf905_dev);	if (retval < 0) {		dev_err(&spi->dev, "Irq request failed/n");		goto err_irq;	}	retval = nrf905_init_chip(nrf905_dev);	if (retval < 0)		goto err_init_chip;	return retval;err_init_chip:	devm_free_irq(nrf905_dev->char_dev,		nrf905_dev->chip.dataready_irq,		nrf905_dev);err_irq:	nrf905_gpio_release(nrf905_dev);err:	return retval;}

static int bma220_probe(struct spi_device *spi){	int ret;	struct iio_dev *indio_dev;	struct bma220_data *data;	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));	if (!indio_dev) {		dev_err(&spi->dev, "iio allocation failed!/n");		return -ENOMEM;	}	data = iio_priv(indio_dev);	data->spi_device = spi;	spi_set_drvdata(spi, indio_dev);	mutex_init(&data->lock);	indio_dev->dev.parent = &spi->dev;	indio_dev->info = &bma220_info;	indio_dev->name = BMA220_DEVICE_NAME;	indio_dev->modes = INDIO_DIRECT_MODE;	indio_dev->channels = bma220_channels;	indio_dev->num_channels = ARRAY_SIZE(bma220_channels);	indio_dev->available_scan_masks = bma220_accel_scan_masks;	ret = bma220_init(data->spi_device);	if (ret < 0)		return ret;	ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time,					 bma220_trigger_handler, NULL);	if (ret < 0) {		dev_err(&spi->dev, "iio triggered buffer setup failed/n");		goto err_suspend;	}	ret = iio_device_register(indio_dev);	if (ret < 0) {		dev_err(&spi->dev, "iio_device_register failed/n");		iio_triggered_buffer_cleanup(indio_dev);		goto err_suspend;	}	return 0;err_suspend:	return bma220_deinit(spi);}

static int bfspi_probe( struct bfspi_device *spi) {	int			status;	struct bfspi_data	*bfspi;	unsigned long		minor;	/* Allocate driver data */	bfspi = kzalloc(sizeof(*bfspi), GFP_KERNEL);	if (!bfspi)		return -ENOMEM;	/* Initialize the driver data */	bfspi->spi = spi;	spin_lock_init(&bfspi->spi_lock);	mutex_init(&bfspi->buf_lock);	INIT_LIST_HEAD(&bfspi->device_entry);	/* If we can allocate a minor number, hook up this device.	 * Reusing minors is fine so long as udev or mdev is working.	 */	mutex_lock(&device_list_lock);	minor = find_first_zero_bit(minors, N_BFSPI_MINORS);	if (minor < N_BFSPI_MINORS) {		struct device *dev;		bfspi->devt = MKDEV(BFSPI_MAJOR, minor);		dev = device_create(bfspi_class, &spi->dev, bfspi->devt,				    bfspi, "bfspi%d.%d",				    spi->master->bus_num, spi->chip_select);		status = IS_ERR(dev) ? PTR_ERR(dev) : 0;	} else {		PRINTK("no minor number available!/n");		status = -ENODEV;	}	if (status == 0) {		set_bit(minor, minors);		list_add(&bfspi->device_entry, &device_list);	}	mutex_unlock(&device_list_lock);	if (status == 0)		spi_set_drvdata(spi, bfspi);		//spi->drv_data = bfspi;	else		kfree(bfspi);		return status;	}

static int pcm3060_spi_probe(struct spi_device *spi){	struct pcm3060_priv *priv;	priv = devm_kzalloc(&spi->dev, sizeof(*priv), GFP_KERNEL);	if (!priv)		return -ENOMEM;	spi_set_drvdata(spi, priv);	priv->regmap = devm_regmap_init_spi(spi, &pcm3060_regmap);	if (IS_ERR(priv->regmap))		return PTR_ERR(priv->regmap);	return pcm3060_probe(&spi->dev);}

static int __devexit st7585_remove(struct spi_device *spi){	struct st7585_data *drvdata = spi_get_drvdata(spi);	spin_lock_irq(&drvdata->lock);	drvdata->spi = NULL;	spi_set_drvdata(spi, NULL);	if (drvdata->info) {		unregister_framebuffer(drvdata->info);		fb_deferred_io_cleanup(drvdata->info);		framebuffer_release(drvdata->info);	}	spin_unlock_irq(&drvdata->lock);		return 0;}

static int __devexit st7735fb_remove(struct spi_device *spi){	struct fb_info *info = spi_get_drvdata(spi);	spi_set_drvdata(spi, NULL);	if (info) {		unregister_framebuffer(info);		vfree(info->screen_base);			framebuffer_release(info);	}	/* TODO: release gpios */	return 0;}

static int cpcap_probe(struct spi_device *spi){	const struct of_device_id *match;	struct cpcap_ddata *cpcap;	int ret;	match = of_match_device(of_match_ptr(cpcap_of_match), &spi->dev);	if (!match)		return -ENODEV;	cpcap = devm_kzalloc(&spi->dev, sizeof(*cpcap), GFP_KERNEL);	if (!cpcap)		return -ENOMEM;	cpcap->spi = spi;	spi_set_drvdata(spi, cpcap);	spi->bits_per_word = 16;	spi->mode = SPI_MODE_0 | SPI_CS_HIGH;	ret = spi_setup(spi);	if (ret)		return ret;	cpcap->regmap_conf = &cpcap_regmap_config;	cpcap->regmap = devm_regmap_init_spi(spi, &cpcap_regmap_config);	if (IS_ERR(cpcap->regmap)) {		ret = PTR_ERR(cpcap->regmap);		dev_err(&cpcap->spi->dev, "Failed to initialize regmap: %d/n",			ret);		return ret;	}	ret = cpcap_check_revision(cpcap);	if (ret) {		dev_err(&cpcap->spi->dev, "Failed to detect CPCAP: %i/n", ret);		return ret;	}	ret = cpcap_init_irq(cpcap);	if (ret)		return ret;	return devm_mfd_add_devices(&spi->dev, 0, cpcap_mfd_devices,				    ARRAY_SIZE(cpcap_mfd_devices), NULL, 0, NULL);}

static int cros_ec_spi_probe(struct spi_device *spi){	struct device *dev = &spi->dev;	struct cros_ec_device *ec_dev;	struct cros_ec_spi *ec_spi;	int err;	spi->bits_per_word = 8;	spi->mode = SPI_MODE_0;	err = spi_setup(spi);	if (err < 0)		return err;	ec_spi = devm_kzalloc(dev, sizeof(*ec_spi), GFP_KERNEL);	if (ec_spi == NULL)		return -ENOMEM;	ec_spi->spi = spi;	ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);	if (!ec_dev)		return -ENOMEM;	/* Check for any DT properties */	cros_ec_spi_dt_probe(ec_spi, dev);	spi_set_drvdata(spi, ec_dev);	ec_dev->dev = dev;	ec_dev->priv = ec_spi;	ec_dev->irq = spi->irq;	ec_dev->cmd_xfer = cros_ec_cmd_xfer_spi;	ec_dev->pkt_xfer = cros_ec_pkt_xfer_spi;	ec_dev->phys_name = dev_name(&ec_spi->spi->dev);	ec_dev->din_size = EC_MSG_PREAMBLE_COUNT +			   sizeof(struct ec_host_response) +			   sizeof(struct ec_response_get_protocol_info);	ec_dev->dout_size = sizeof(struct ec_host_request);	err = cros_ec_register(ec_dev);	if (err) {		dev_err(dev, "cannot register EC/n");		return err;	}	device_init_wakeup(&spi->dev, true);	return 0;}

static int pmic_probe(struct spi_device *spi){	struct tps6524x *hw;	struct device *dev = &spi->dev;	const struct supply_info *info = supply_info;	struct regulator_init_data *init_data;	struct regulator_config config = { };	struct regulator_dev *rdev;	int i;	init_data = dev_get_platdata(dev);	if (!init_data) {		dev_err(dev, "could not find regulator platform data/n");		return -EINVAL;	}	hw = devm_kzalloc(&spi->dev, sizeof(struct tps6524x), GFP_KERNEL);	if (!hw)		return -ENOMEM;	spi_set_drvdata(spi, hw);	memset(hw, 0, sizeof(struct tps6524x));	hw->dev = dev;	hw->spi = spi;	mutex_init(&hw->lock);	for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {		hw->desc[i].name	= info->name;		hw->desc[i].id		= i;		hw->desc[i].n_voltages	= info->n_voltages;		hw->desc[i].volt_table	= info->voltages;		hw->desc[i].ops		= &regulator_ops;		hw->desc[i].type	= REGULATOR_VOLTAGE;		hw->desc[i].owner	= THIS_MODULE;		config.dev = dev;		config.init_data = init_data;		config.driver_data = hw;		rdev = devm_regulator_register(dev, &hw->desc[i], &config);		if (IS_ERR(rdev))			return PTR_ERR(rdev);	}	return 0;}

static int ak4104_spi_probe(struct spi_device *spi){	struct ak4104_private *ak4104;	unsigned int val;	int ret;	spi->bits_per_word = 8;	spi->mode = SPI_MODE_0;	ret = spi_setup(spi);	if (ret < 0)		return ret;	ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private),			      GFP_KERNEL);	if (ak4104 == NULL)		return -ENOMEM;	ak4104->regmap = regmap_init_spi(spi, &ak4104_regmap);	if (IS_ERR(ak4104->regmap)) {		ret = PTR_ERR(ak4104->regmap);		return ret;	}	/*                                                                                                                                                                                     */	ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val);	if (ret != 0)		goto err;	if (val != AK4104_RESERVED_VAL) {		ret = -ENODEV;		goto err;	}	spi_set_drvdata(spi, ak4104);	ret = snd_soc_register_codec(&spi->dev,			&soc_codec_device_ak4104, &ak4104_dai, 1);	if (ret != 0)		goto err;	return 0;err:	regmap_exit(ak4104->regmap);	return ret;}

static int st7735r_probe(struct spi_device *spi){	struct device *dev = &spi->dev;	struct mipi_dbi *mipi;	struct gpio_desc *dc;	u32 rotation = 0;	int ret;	mipi = devm_kzalloc(dev, sizeof(*mipi), GFP_KERNEL);	if (!mipi)		return -ENOMEM;	mipi->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);	if (IS_ERR(mipi->reset)) {		DRM_DEV_ERROR(dev, "Failed to get gpio 'reset'/n");		return PTR_ERR(mipi->reset);	}	dc = devm_gpiod_get(dev, "dc", GPIOD_OUT_LOW);	if (IS_ERR(dc)) {		DRM_DEV_ERROR(dev, "Failed to get gpio 'dc'/n");		return PTR_ERR(dc);	}	mipi->backlight = devm_of_find_backlight(dev);	if (IS_ERR(mipi->backlight))		return PTR_ERR(mipi->backlight);	device_property_read_u32(dev, "rotation", &rotation);	ret = mipi_dbi_spi_init(spi, mipi, dc);	if (ret)		return ret;	/* Cannot read from Adafruit 1.8" display via SPI */	mipi->read_commands = NULL;	ret = mipi_dbi_init(&spi->dev, mipi, &jd_t18003_t01_pipe_funcs,			    &st7735r_driver, &jd_t18003_t01_mode, rotation);	if (ret)		return ret;	spi_set_drvdata(spi, mipi);	return devm_tinydrm_register(&mipi->tinydrm);}

static int cs4271_spi_probe(struct spi_device *spi){	struct cs4271_private *cs4271;	int ret;	ret = cs4271_common_probe(&spi->dev, &cs4271);	if (ret < 0)		return ret;	spi_set_drvdata(spi, cs4271);	cs4271->regmap = devm_regmap_init_spi(spi, &cs4271_spi_regmap);	if (IS_ERR(cs4271->regmap))		return PTR_ERR(cs4271->regmap);	return snd_soc_register_codec(&spi->dev, &soc_codec_dev_cs4271,		&cs4271_dai, 1);}

static int m10mo_spi_probe(struct spi_device *spi){	int ret = -ENODEV;	struct m10mo_spi *m10mo_spi_dev;	struct m10mo_atomisp_spi_platform_data *pdata;	dev_dbg(&spi->dev, "Probe M10MO SPI/n");	pdata = dev_get_platdata(&spi->dev);	if (!pdata) {		dev_err(&spi->dev, "Missing platform data. Can't continue");		return -ENODEV;	}	if (!pdata->device_data) {		dev_err(&spi->dev, "Missing link to m10mo main driver. Can't continue");		return -ENODEV;	}	m10mo_spi_dev = kzalloc(sizeof(struct m10mo_spi), GFP_KERNEL);	if (!m10mo_spi_dev) {		dev_err(&spi->dev, "Can't get memory/n");		return -ENOMEM;	}	if (spi_setup(spi)) {		dev_err(&spi->dev, "failed to setup spi for m10mo_spi/n");		ret = -EINVAL;		goto err_setup;	}	spi_set_drvdata(spi, m10mo_spi_dev);	m10mo_spi_dev->spi_device  = spi;	m10mo_spi_dev->read        = m10mo_spi_read;	m10mo_spi_dev->write       = m10mo_spi_write;	m10mo_spi_dev->spi_enabled = pdata->spi_enabled;	m10mo_register_spi_fw_flash_interface(pdata->device_data,					      m10mo_spi_dev);	dev_err(&spi->dev, "m10mo_spi successfully probed/n");	return 0;err_setup:	kfree(m10mo_spi_dev);	return ret;}

static int wm8770_spi_probe(struct spi_device *spi){	struct wm8770_priv *wm8770;	int ret, i;	wm8770 = devm_kzalloc(&spi->dev, sizeof(struct wm8770_priv),			      GFP_KERNEL);	if (!wm8770)		return -ENOMEM;	for (i = 0; i < ARRAY_SIZE(wm8770->supplies); i++)		wm8770->supplies[i].supply = wm8770_supply_names[i];	ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8770->supplies),				      wm8770->supplies);	if (ret) {		dev_err(&spi->dev, "Failed to request supplies: %d/n", ret);		return ret;	}	wm8770->disable_nb[0].notifier_call = wm8770_regulator_event_0;	wm8770->disable_nb[1].notifier_call = wm8770_regulator_event_1;	wm8770->disable_nb[2].notifier_call = wm8770_regulator_event_2;	/* This should really be moved into the regulator core */	for (i = 0; i < ARRAY_SIZE(wm8770->supplies); i++) {		ret = regulator_register_notifier(wm8770->supplies[i].consumer,						  &wm8770->disable_nb[i]);		if (ret) {			dev_err(&spi->dev,				"Failed to register regulator notifier: %d/n",				ret);		}	}	wm8770->regmap = devm_regmap_init_spi(spi, &wm8770_regmap);	if (IS_ERR(wm8770->regmap))		return PTR_ERR(wm8770->regmap);	spi_set_drvdata(spi, wm8770);	ret = devm_snd_soc_register_component(&spi->dev,				     &soc_component_dev_wm8770, &wm8770_dai, 1);	return ret;}

/* Bind driver to board_info using modalias "mcp3901" */static int __devinit mcp3901_probe(struct spi_device *spi){	struct mcp3901_state             *state;	struct mcp3901_platform_data     *pdata;	pdata = spi->dev.platform_data;	if(!pdata)		return -ENODEV;	state = kzalloc(sizeof(struct mcp3901_state), GFP_KERNEL);	if(!state)		return -ENOMEM;	spi_set_drvdata(spi, state);	return 0;}