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 sc16is7x_probe(struct spi_device *spi) { struct sc16is7x_platform_data *pdata; struct sc16is7x_chip *chip; int res = 0; spi->mode = SPI_MODE_0; spi->bits_per_word = 8; spi_setup(spi); printk(KERN_INFO "SC16IS7X: Probe Called...\n"); pdata = spi->dev.platform_data; if (pdata == NULL) { dev_err(&spi->dev, "No platform data...\n"); return -EINVAL; } chip = kzalloc(sizeof(struct sc16is7x_chip), GFP_KERNEL); if (!chip) return -ENOMEM; spi_set_drvdata(spi, chip); chip->spi_dev = spi; chip->base = pdata->gpio_base; chip->names = pdata->names; sc16is7x_setup_gpio(chip,8); res = sc16is7x_read_reg(chip, SC16IS7X_STATE, &chip->reg_state); if (res) goto failed; res = sc16is7x_read_reg(chip, SC16IS7X_DIRECTION, &chip->reg_direction); if (res) goto failed; res = gpiochip_add(&chip->gpio_chip); if (res) { dev_err(&chip->spi_dev->dev, "failed adding gpios\n"); goto failed; } if (pdata->setup) { res = pdata->setup(spi,chip->gpio_chip.base, chip->gpio_chip.ngpio, pdata->context); } return 0; failed: kfree(chip); return res; }
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 = ®ulator_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 = ®ulator_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; }