static int wm8741_spi_probe(struct spi_device *spi) { struct wm8741_priv *wm8741; int ret, i; wm8741 = devm_kzalloc(&spi->dev, sizeof(struct wm8741_priv), GFP_KERNEL); if (wm8741 == NULL) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++) wm8741->supplies[i].supply = wm8741_supply_names[i]; ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8741->supplies), wm8741->supplies); if (ret != 0) { dev_err(&spi->dev, "Failed to request supplies: %d\n", ret); return ret; } wm8741->regmap = devm_regmap_init_spi(spi, &wm8741_regmap); if (IS_ERR(wm8741->regmap)) { ret = PTR_ERR(wm8741->regmap); dev_err(&spi->dev, "Failed to init regmap: %d\n", ret); return ret; } ret = wm8741_set_pdata(&spi->dev, wm8741); if (ret != 0) { dev_err(&spi->dev, "Failed to set pdata: %d\n", ret); return ret; } spi_set_drvdata(spi, wm8741); ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_wm8741, &wm8741_dai, 1); return ret; }
static int ad1836_spi_probe(struct spi_device *spi) { struct ad1836_priv *ad1836; int ret; ad1836 = devm_kzalloc(&spi->dev, sizeof(struct ad1836_priv), GFP_KERNEL); if (ad1836 == NULL) return -ENOMEM; ad1836->regmap = devm_regmap_init_spi(spi, &ad1836_regmap_config); if (IS_ERR(ad1836->regmap)) return PTR_ERR(ad1836->regmap); ad1836->type = spi_get_device_id(spi)->driver_data; spi_set_drvdata(spi, ad1836); ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_ad1836, &ad183x_dais[ad1836->type], 1); return ret; }
static int pcm1792a_spi_probe(struct spi_device *spi) { struct pcm1792a_private *pcm1792a; int ret; pcm1792a = devm_kzalloc(&spi->dev, sizeof(struct pcm1792a_private), GFP_KERNEL); if (!pcm1792a) return -ENOMEM; spi_set_drvdata(spi, pcm1792a); pcm1792a->regmap = devm_regmap_init_spi(spi, &pcm1792a_regmap); if (IS_ERR(pcm1792a->regmap)) { ret = PTR_ERR(pcm1792a->regmap); dev_err(&spi->dev, "Failed to register regmap: %d\n", ret); return ret; } return snd_soc_register_codec(&spi->dev, &soc_codec_dev_pcm1792a, &pcm1792a_dai, 1); }
static int wm8988_spi_probe(struct spi_device *spi) { struct wm8988_priv *wm8988; int ret; wm8988 = devm_kzalloc(&spi->dev, sizeof(struct wm8988_priv), GFP_KERNEL); if (wm8988 == NULL) return -ENOMEM; wm8988->regmap = devm_regmap_init_spi(spi, &wm8988_regmap); if (IS_ERR(wm8988->regmap)) { ret = PTR_ERR(wm8988->regmap); dev_err(&spi->dev, "Failed to init regmap: %d\n", ret); return ret; } spi_set_drvdata(spi, wm8988); ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_wm8988, &wm8988_dai, 1); return ret; }
static int es8328_spi_probe(struct spi_device *spi) { struct es8328_priv *es8328; int ret; es8328 = devm_kzalloc(&spi->dev, sizeof(struct es8328_priv), GFP_KERNEL); if (es8328 == NULL) return -ENOMEM; es8328->regmap = devm_regmap_init_spi(spi, &es8328_regmap); if (IS_ERR(es8328->regmap)) return PTR_ERR(es8328->regmap); spi_set_drvdata(spi, es8328); ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_es8328, &es8328_dai, 1); if (ret < 0) dev_err(&spi->dev, "Unable to register codec: %d\n", ret); return ret; }
static int da9052_spi_probe(struct spi_device *spi) { struct regmap_config config; int ret; const struct spi_device_id *id = spi_get_device_id(spi); struct da9052 *da9052; da9052 = devm_kzalloc(&spi->dev, sizeof(struct da9052), GFP_KERNEL); if (!da9052) return -ENOMEM; spi->mode = SPI_MODE_0; spi->bits_per_word = 8; spi_setup(spi); da9052->dev = &spi->dev; da9052->chip_irq = spi->irq; spi_set_drvdata(spi, da9052); config = da9052_regmap_config; config.read_flag_mask = 1; config.reg_bits = 7; config.pad_bits = 1; config.val_bits = 8; config.use_single_rw = 1; da9052->regmap = devm_regmap_init_spi(spi, &config); if (IS_ERR(da9052->regmap)) { ret = PTR_ERR(da9052->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } return da9052_device_init(da9052, id->driver_data); }
static int da9052_spi_probe(struct spi_device *spi) { int ret; const struct spi_device_id *id = spi_get_device_id(spi); struct da9052 *da9052; da9052 = devm_kzalloc(&spi->dev, sizeof(struct da9052), GFP_KERNEL); if (!da9052) return -ENOMEM; spi->mode = SPI_MODE_0 | SPI_CPOL; spi->bits_per_word = 8; spi_setup(spi); da9052->dev = &spi->dev; da9052->chip_irq = spi->irq; spi_set_drvdata(spi, da9052); da9052_regmap_config.read_flag_mask = 1; da9052_regmap_config.write_flag_mask = 0; da9052->regmap = devm_regmap_init_spi(spi, &da9052_regmap_config); if (IS_ERR(da9052->regmap)) { ret = PTR_ERR(da9052->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } ret = da9052_device_init(da9052, id->driver_data); if (ret != 0) return ret; return 0; }
static int altr_a10sr_spi_probe(struct spi_device *spi) { int ret; struct altr_a10sr *a10sr; a10sr = devm_kzalloc(&spi->dev, sizeof(*a10sr), GFP_KERNEL); if (!a10sr) return -ENOMEM; spi->mode = SPI_MODE_3; spi->bits_per_word = 8; spi_setup(spi); a10sr->dev = &spi->dev; spi_set_drvdata(spi, a10sr); a10sr->regmap = devm_regmap_init_spi(spi, &altr_a10sr_regmap_config); if (IS_ERR(a10sr->regmap)) { ret = PTR_ERR(a10sr->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } ret = devm_mfd_add_devices(a10sr->dev, PLATFORM_DEVID_AUTO, altr_a10sr_subdev_info, ARRAY_SIZE(altr_a10sr_subdev_info), NULL, 0, NULL); if (ret) dev_err(a10sr->dev, "Failed to register sub-devices: %d\n", ret); return ret; }
static int ds1343_probe(struct spi_device *spi) { struct ds1343_priv *priv; struct regmap_config config = { .reg_bits = 8, .val_bits = 8, .write_flag_mask = 0x80, }; unsigned int data; int res; struct nvmem_config nvmem_cfg = { .name = "ds1343-", .word_size = 1, .stride = 1, .size = DS1343_NVRAM_LEN, .reg_read = ds1343_nvram_read, .reg_write = ds1343_nvram_write, }; priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->spi = spi; mutex_init(&priv->mutex); /* RTC DS1347 works in spi mode 3 and * its chip select is active high */ spi->mode = SPI_MODE_3 | SPI_CS_HIGH; spi->bits_per_word = 8; res = spi_setup(spi); if (res) return res; spi_set_drvdata(spi, priv); priv->map = devm_regmap_init_spi(spi, &config); if (IS_ERR(priv->map)) { dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n"); return PTR_ERR(priv->map); } res = regmap_read(priv->map, DS1343_SECONDS_REG, &data); if (res) return res; regmap_read(priv->map, DS1343_CONTROL_REG, &data); data |= DS1343_INTCN; data &= ~(DS1343_EOSC | DS1343_A1IE | DS1343_A0IE); regmap_write(priv->map, DS1343_CONTROL_REG, data); regmap_read(priv->map, DS1343_STATUS_REG, &data); data &= ~(DS1343_OSF | DS1343_IRQF1 | DS1343_IRQF0); regmap_write(priv->map, DS1343_STATUS_REG, data); priv->rtc = devm_rtc_allocate_device(&spi->dev); if (IS_ERR(priv->rtc)) return PTR_ERR(priv->rtc); priv->rtc->nvram_old_abi = true; priv->rtc->ops = &ds1343_rtc_ops; res = rtc_register_device(priv->rtc); if (res) return res; nvmem_cfg.priv = priv; rtc_nvmem_register(priv->rtc, &nvmem_cfg); priv->irq = spi->irq; if (priv->irq >= 0) { res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL, ds1343_thread, IRQF_ONESHOT, "ds1343", priv); if (res) { priv->irq = -1; dev_err(&spi->dev, "unable to request irq for rtc ds1343\n"); } else { device_init_wakeup(&spi->dev, true); dev_pm_set_wake_irq(&spi->dev, spi->irq); } } res = ds1343_sysfs_register(&spi->dev); if (res) dev_err(&spi->dev, "unable to create sysfs entries for rtc ds1343\n"); return 0; } static int ds1343_remove(struct spi_device *spi) { struct ds1343_priv *priv = spi_get_drvdata(spi); if (spi->irq) { mutex_lock(&priv->mutex); priv->irqen &= ~RTC_AF; mutex_unlock(&priv->mutex); dev_pm_clear_wake_irq(&spi->dev); device_init_wakeup(&spi->dev, false); devm_free_irq(&spi->dev, spi->irq, priv); } spi_set_drvdata(spi, NULL); ds1343_sysfs_unregister(&spi->dev); return 0; } #ifdef CONFIG_PM_SLEEP static int ds1343_suspend(struct device *dev) { struct spi_device *spi = to_spi_device(dev); if (spi->irq >= 0 && device_may_wakeup(dev)) enable_irq_wake(spi->irq); return 0; } static int ds1343_resume(struct device *dev) { struct spi_device *spi = to_spi_device(dev); if (spi->irq >= 0 && device_may_wakeup(dev)) disable_irq_wake(spi->irq); return 0; } #endif static SIMPLE_DEV_PM_OPS(ds1343_pm, ds1343_suspend, ds1343_resume); static struct spi_driver ds1343_driver = { .driver = { .name = "ds1343", .pm = &ds1343_pm, }, .probe = ds1343_probe, .remove = ds1343_remove, .id_table = ds1343_id, }; module_spi_driver(ds1343_driver); MODULE_DESCRIPTION("DS1343 RTC SPI Driver"); MODULE_AUTHOR("Raghavendra Chandra Ganiga <*****@*****.**>," "Ankur Srivastava <*****@*****.**>"); MODULE_LICENSE("GPL v2");
static int ds3234_probe(struct spi_device *spi) { int res; unsigned int tmp; static const struct regmap_config config = { .reg_bits = 8, .val_bits = 8, .max_register = 0x13, .write_flag_mask = 0x80, }; struct regmap *regmap; regmap = devm_regmap_init_spi(spi, &config); if (IS_ERR(regmap)) { dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n", __func__, PTR_ERR(regmap)); return PTR_ERR(regmap); } spi->mode = SPI_MODE_3; spi->bits_per_word = 8; spi_setup(spi); res = regmap_read(regmap, DS3232_REG_SECONDS, &tmp); if (res) 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 */ res = regmap_read(regmap, DS3232_REG_CR, &tmp); if (res) return res; res = regmap_write(regmap, DS3232_REG_CR, tmp & 0x1c); if (res) return res; res = regmap_read(regmap, DS3232_REG_SR, &tmp); if (res) return res; res = regmap_write(regmap, DS3232_REG_SR, tmp & 0x88); if (res) return res; /* Print our settings */ res = regmap_read(regmap, DS3232_REG_CR, &tmp); if (res) return res; dev_info(&spi->dev, "Control Reg: 0x%02x\n", tmp); res = regmap_read(regmap, DS3232_REG_SR, &tmp); if (res) return res; dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x\n", tmp); return ds3232_probe(&spi->dev, regmap, spi->irq, "ds3234"); } static struct spi_driver ds3234_driver = { .driver = { .name = "ds3234", }, .probe = ds3234_probe, };
static int es8328_spi_probe(struct spi_device *spi) { return es8328_probe(&spi->dev, devm_regmap_init_spi(spi, &es8328_regmap_config)); }
static int ds1343_probe(struct spi_device *spi) { struct ds1343_priv *priv; struct regmap_config config; unsigned int data; int res; memset(&config, 0, sizeof(config)); config.reg_bits = 8; config.val_bits = 8; config.write_flag_mask = 0x80; priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->spi = spi; mutex_init(&priv->mutex); /* RTC DS1347 works in spi mode 3 and * its chip select is active high */ spi->mode = SPI_MODE_3 | SPI_CS_HIGH; spi->bits_per_word = 8; res = spi_setup(spi); if (res) return res; spi_set_drvdata(spi, priv); priv->map = devm_regmap_init_spi(spi, &config); if (IS_ERR(priv->map)) { dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n"); return PTR_ERR(priv->map); } res = regmap_read(priv->map, DS1343_SECONDS_REG, &data); if (res) return res; regmap_read(priv->map, DS1343_CONTROL_REG, &data); data |= DS1343_INTCN; data &= ~(DS1343_EOSC | DS1343_A1IE | DS1343_A0IE); regmap_write(priv->map, DS1343_CONTROL_REG, data); regmap_read(priv->map, DS1343_STATUS_REG, &data); data &= ~(DS1343_OSF | DS1343_IRQF1 | DS1343_IRQF0); regmap_write(priv->map, DS1343_STATUS_REG, data); priv->rtc = devm_rtc_device_register(&spi->dev, "ds1343", &ds1343_rtc_ops, THIS_MODULE); if (IS_ERR(priv->rtc)) { dev_err(&spi->dev, "unable to register rtc ds1343\n"); return PTR_ERR(priv->rtc); } priv->irq = spi->irq; if (priv->irq >= 0) { res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL, ds1343_thread, IRQF_NO_SUSPEND | IRQF_ONESHOT, "ds1343", priv); if (res) { priv->irq = -1; dev_err(&spi->dev, "unable to request irq for rtc ds1343\n"); } else { device_set_wakeup_capable(&spi->dev, 1); } } res = ds1343_sysfs_register(&spi->dev); if (res) dev_err(&spi->dev, "unable to create sysfs entries for rtc ds1343\n"); return 0; }
static int arizona_spi_probe(struct spi_device *spi) { const struct spi_device_id *id = spi_get_device_id(spi); struct arizona *arizona; const struct regmap_config *regmap_config; const struct regmap_config *regmap_32bit_config = NULL; unsigned long type; int ret; if (spi->dev.of_node) type = arizona_of_get_type(&spi->dev); else type = id->driver_data; switch (type) { #ifdef CONFIG_MFD_WM5102 case WM5102: regmap_config = &wm5102_spi_regmap; break; #endif #ifdef CONFIG_MFD_FLORIDA case WM8280: case WM5110: regmap_config = &florida_spi_regmap; break; #endif #ifdef CONFIG_MFD_CLEARWATER case WM8285: case WM1840: regmap_config = &clearwater_16bit_spi_regmap; regmap_32bit_config = &clearwater_32bit_spi_regmap; break; #endif #ifdef CONFIG_MFD_LARGO case WM1831: case CS47L24: regmap_config = &largo_spi_regmap; break; #endif #ifdef CONFIG_MFD_MARLEY case CS47L35: regmap_config = &marley_16bit_spi_regmap; regmap_32bit_config = &marley_32bit_spi_regmap; break; #endif #ifdef CONFIG_MFD_MOON case CS47L90: case CS47L91: regmap_config = &moon_16bit_spi_regmap; regmap_32bit_config = &moon_32bit_spi_regmap; break; #endif default: dev_err(&spi->dev, "Unknown device type %ld\n", id->driver_data); return -EINVAL; } arizona = devm_kzalloc(&spi->dev, sizeof(*arizona), GFP_KERNEL); if (arizona == NULL) return -ENOMEM; arizona->regmap = devm_regmap_init_spi(spi, regmap_config); if (IS_ERR(arizona->regmap)) { ret = PTR_ERR(arizona->regmap); dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret); return ret; } if (regmap_32bit_config) { arizona->regmap_32bit = devm_regmap_init_spi(spi, regmap_32bit_config); if (IS_ERR(arizona->regmap_32bit)) { ret = PTR_ERR(arizona->regmap_32bit); dev_err(&spi->dev, "Failed to allocate dsp register map: %d\n", ret); return ret; } } arizona->type = id->driver_data; arizona->dev = &spi->dev; arizona->irq = spi->irq; return arizona_dev_init(arizona); }