static int snd_soc_dummy_probe(struct platform_device *pdev) { int ret; ret = devm_snd_soc_register_component(&pdev->dev, &dummy_codec, &dummy_dai, 1); if (ret < 0) return ret; ret = devm_snd_soc_register_component(&pdev->dev, &dummy_platform, NULL, 0); return ret; }
static int wm8524_codec_probe(struct platform_device *pdev) { struct wm8524_priv *wm8524; int ret; wm8524 = devm_kzalloc(&pdev->dev, sizeof(struct wm8524_priv), GFP_KERNEL); if (wm8524 == NULL) return -ENOMEM; platform_set_drvdata(pdev, wm8524); wm8524->mute = devm_gpiod_get(&pdev->dev, "wlf,mute", GPIOD_OUT_LOW); if (IS_ERR(wm8524->mute)) { ret = PTR_ERR(wm8524->mute); dev_err(&pdev->dev, "Failed to get mute line: %d\n", ret); return ret; } ret = devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_wm8524, &wm8524_dai, 1); if (ret < 0) dev_err(&pdev->dev, "Failed to register component: %d\n", ret); return ret; }
static int uda134x_codec_probe(struct platform_device *pdev) { struct uda134x_platform_data *pd = pdev->dev.platform_data; struct uda134x_priv *uda134x; int ret; if (!pd) { dev_err(&pdev->dev, "Missing L3 bitbang function\n"); return -ENODEV; } uda134x = devm_kzalloc(&pdev->dev, sizeof(*uda134x), GFP_KERNEL); if (!uda134x) return -ENOMEM; uda134x->pd = pd; platform_set_drvdata(pdev, uda134x); if (pd->l3.use_gpios) { ret = l3_set_gpio_ops(&pdev->dev, &uda134x->pd->l3); if (ret < 0) return ret; } uda134x->regmap = devm_regmap_init(&pdev->dev, NULL, pd, &uda134x_regmap_config); if (IS_ERR(uda134x->regmap)) return PTR_ERR(uda134x->regmap); return devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_uda134x, &uda134x_dai, 1); }
int pcm1789_common_init(struct device *dev, struct regmap *regmap) { struct pcm1789_private *pcm1789; pcm1789 = devm_kzalloc(dev, sizeof(struct pcm1789_private), GFP_KERNEL); if (!pcm1789) return -ENOMEM; pcm1789->regmap = regmap; pcm1789->dev = dev; dev_set_drvdata(dev, pcm1789); pcm1789->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(pcm1789->reset)) return PTR_ERR(pcm1789->reset); gpiod_set_value_cansleep(pcm1789->reset, 0); msleep(300); INIT_WORK(&pcm1789->work, pcm1789_work_queue); return devm_snd_soc_register_component(dev, &soc_component_dev_pcm1789, &pcm1789_dai, 1); }
static int mt6351_codec_driver_probe(struct platform_device *pdev) { struct mt6351_priv *priv; priv = devm_kzalloc(&pdev->dev, sizeof(struct mt6351_priv), GFP_KERNEL); if (!priv) return -ENOMEM; dev_set_drvdata(&pdev->dev, priv); priv->dev = &pdev->dev; priv->regmap = dev_get_regmap(pdev->dev.parent, NULL); if (!priv->regmap) return -ENODEV; dev_dbg(priv->dev, "%s(), dev name %s\n", __func__, dev_name(&pdev->dev)); return devm_snd_soc_register_component(&pdev->dev, &mt6351_soc_component_driver, mt6351_dai_driver, ARRAY_SIZE(mt6351_dai_driver)); }
static int s3c24xx_iis_dev_probe(struct platform_device *pdev) { struct resource *res; int ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); s3c24xx_i2s.regs = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(s3c24xx_i2s.regs)) return PTR_ERR(s3c24xx_i2s.regs); s3c24xx_i2s_pcm_stereo_out.addr = res->start + S3C2410_IISFIFO; s3c24xx_i2s_pcm_stereo_in.addr = res->start + S3C2410_IISFIFO; ret = samsung_asoc_dma_platform_register(&pdev->dev, NULL, NULL, NULL); if (ret) { dev_err(&pdev->dev, "Failed to register the DMA: %d\n", ret); return ret; } ret = devm_snd_soc_register_component(&pdev->dev, &s3c24xx_i2s_component, &s3c24xx_i2s_dai, 1); if (ret) dev_err(&pdev->dev, "Failed to register the DAI\n"); return ret; }
static int sta529_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct sta529 *sta529; int ret; sta529 = devm_kzalloc(&i2c->dev, sizeof(struct sta529), GFP_KERNEL); if (!sta529) return -ENOMEM; sta529->regmap = devm_regmap_init_i2c(i2c, &sta529_regmap); if (IS_ERR(sta529->regmap)) { ret = PTR_ERR(sta529->regmap); dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret); return ret; } i2c_set_clientdata(i2c, sta529); ret = devm_snd_soc_register_component(&i2c->dev, &sta529_component_driver, &sta529_dai, 1); if (ret != 0) dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); return ret; }
static int jz4740_i2s_dev_probe(struct platform_device *pdev) { struct jz4740_i2s *i2s; struct resource *mem; int ret; i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL); if (!i2s) return -ENOMEM; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2s->base = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(i2s->base)) return PTR_ERR(i2s->base); i2s->phys_base = mem->start; i2s->clk_aic = devm_clk_get(&pdev->dev, "aic"); if (IS_ERR(i2s->clk_aic)) return PTR_ERR(i2s->clk_aic); i2s->clk_i2s = devm_clk_get(&pdev->dev, "i2s"); if (IS_ERR(i2s->clk_i2s)) return PTR_ERR(i2s->clk_i2s); platform_set_drvdata(pdev, i2s); ret = devm_snd_soc_register_component(&pdev->dev, &jz4740_i2s_component, &jz4740_i2s_dai, 1); if (ret) return ret; return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, SND_DMAENGINE_PCM_FLAG_COMPAT); }
static int ak5558_i2c_probe(struct i2c_client *i2c) { struct ak5558_priv *ak5558; int ret = 0; ak5558 = devm_kzalloc(&i2c->dev, sizeof(*ak5558), GFP_KERNEL); if (!ak5558) return -ENOMEM; ak5558->regmap = devm_regmap_init_i2c(i2c, &ak5558_regmap); if (IS_ERR(ak5558->regmap)) return PTR_ERR(ak5558->regmap); i2c_set_clientdata(i2c, ak5558); ak5558->i2c = i2c; ak5558->reset_gpiod = devm_gpiod_get_optional(&i2c->dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(ak5558->reset_gpiod)) return PTR_ERR(ak5558->reset_gpiod); ret = devm_snd_soc_register_component(&i2c->dev, &soc_codec_dev_ak5558, &ak5558_dai, 1); if (ret) return ret; pm_runtime_enable(&i2c->dev); return 0; }
static int __init mc13783_codec_probe(struct platform_device *pdev) { struct mc13783_priv *priv; struct mc13xxx_codec_platform_data *pdata = pdev->dev.platform_data; struct device_node *np; int ret; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; if (pdata) { priv->adc_ssi_port = pdata->adc_ssi_port; priv->dac_ssi_port = pdata->dac_ssi_port; } else { np = of_get_child_by_name(pdev->dev.parent->of_node, "codec"); if (!np) return -ENOSYS; ret = of_property_read_u32(np, "adc-port", &priv->adc_ssi_port); if (ret) { of_node_put(np); return ret; } ret = of_property_read_u32(np, "dac-port", &priv->dac_ssi_port); if (ret) { of_node_put(np); return ret; } of_node_put(np); } dev_set_drvdata(&pdev->dev, priv); priv->mc13xxx = dev_get_drvdata(pdev->dev.parent); if (priv->adc_ssi_port == priv->dac_ssi_port) ret = devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_mc13783, mc13783_dai_sync, ARRAY_SIZE(mc13783_dai_sync)); else ret = devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_mc13783, mc13783_dai_async, ARRAY_SIZE(mc13783_dai_async)); return ret; }
static int jz4740_i2s_dev_probe(struct platform_device *pdev) { struct jz4740_i2s *i2s; struct resource *mem; int ret; const struct of_device_id *match; i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL); if (!i2s) return -ENOMEM; match = of_match_device(jz4740_of_matches, &pdev->dev); if (match) i2s->version = (enum jz47xx_i2s_version)match->data; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2s->base = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(i2s->base)) return PTR_ERR(i2s->base); i2s->phys_base = mem->start; i2s->clk_aic = devm_clk_get(&pdev->dev, "aic"); if (IS_ERR(i2s->clk_aic)) return PTR_ERR(i2s->clk_aic); i2s->clk_i2s = devm_clk_get(&pdev->dev, "i2s"); if (IS_ERR(i2s->clk_i2s)) return PTR_ERR(i2s->clk_i2s); platform_set_drvdata(pdev, i2s); if (i2s->version == JZ_I2S_JZ4780) ret = devm_snd_soc_register_component(&pdev->dev, &jz4740_i2s_component, &jz4780_i2s_dai, 1); else ret = devm_snd_soc_register_component(&pdev->dev, &jz4740_i2s_component, &jz4740_i2s_dai, 1); if (ret) return ret; return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, SND_DMAENGINE_PCM_FLAG_COMPAT); }
static int asoc_idma_platform_probe(struct platform_device *pdev) { idma_irq = platform_get_irq(pdev, 0); if (idma_irq < 0) return idma_irq; return devm_snd_soc_register_component(&pdev->dev, &asoc_idma_platform, NULL, 0); }
static int tas5720_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct tas5720_data *data; const struct regmap_config *regmap_config; int ret; int i; data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; data->tas5720_client = client; data->devtype = id->driver_data; switch (id->driver_data) { case TAS5720: regmap_config = &tas5720_regmap_config; break; case TAS5722: regmap_config = &tas5722_regmap_config; break; default: dev_err(dev, "unexpected private driver data\n"); return -EINVAL; } data->regmap = devm_regmap_init_i2c(client, regmap_config); if (IS_ERR(data->regmap)) { ret = PTR_ERR(data->regmap); dev_err(dev, "failed to allocate register map: %d\n", ret); return ret; } for (i = 0; i < ARRAY_SIZE(data->supplies); i++) data->supplies[i].supply = tas5720_supply_names[i]; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies), data->supplies); if (ret != 0) { dev_err(dev, "failed to request supplies: %d\n", ret); return ret; } dev_set_drvdata(dev, data); ret = devm_snd_soc_register_component(&client->dev, &soc_component_dev_tas5720, tas5720_dai, ARRAY_SIZE(tas5720_dai)); if (ret < 0) { dev_err(dev, "failed to register component: %d\n", ret); return ret; } return 0; }
static int max98373_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { int ret = 0; int reg = 0; struct max98373_priv *max98373 = NULL; max98373 = devm_kzalloc(&i2c->dev, sizeof(*max98373), GFP_KERNEL); if (!max98373) { ret = -ENOMEM; return ret; } i2c_set_clientdata(i2c, max98373); /* update interleave mode info */ if (device_property_read_bool(&i2c->dev, "maxim,interleave_mode")) max98373->interleave_mode = 1; else max98373->interleave_mode = 0; /* regmap initialization */ max98373->regmap = devm_regmap_init_i2c(i2c, &max98373_regmap); if (IS_ERR(max98373->regmap)) { ret = PTR_ERR(max98373->regmap); dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret); return ret; } /* Check Revision ID */ ret = regmap_read(max98373->regmap, MAX98373_R21FF_REV_ID, ®); if (ret < 0) { dev_err(&i2c->dev, "Failed to read: 0x%02X\n", MAX98373_R21FF_REV_ID); return ret; } dev_info(&i2c->dev, "MAX98373 revisionID: 0x%02X\n", reg); /* voltage/current slot configuration */ max98373_slot_config(i2c, max98373); /* codec registeration */ ret = devm_snd_soc_register_component(&i2c->dev, &soc_codec_dev_max98373, max98373_dai, ARRAY_SIZE(max98373_dai)); if (ret < 0) dev_err(&i2c->dev, "Failed to register codec: %d\n", ret); return ret; }
static int stm32_sai_sub_probe(struct platform_device *pdev) { struct stm32_sai_sub_data *sai; const struct of_device_id *of_id; int ret; sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL); if (!sai) return -ENOMEM; of_id = of_match_device(stm32_sai_sub_ids, &pdev->dev); if (!of_id) return -EINVAL; sai->id = (uintptr_t)of_id->data; sai->pdev = pdev; platform_set_drvdata(pdev, sai); sai->pdata = dev_get_drvdata(pdev->dev.parent); if (!sai->pdata) { dev_err(&pdev->dev, "Parent device data not available\n"); return -EINVAL; } ret = stm32_sai_sub_parse_of(pdev, sai); if (ret) return ret; ret = stm32_sai_sub_dais_init(pdev, sai); if (ret) return ret; ret = devm_request_irq(&pdev->dev, sai->pdata->irq, stm32_sai_isr, IRQF_SHARED, dev_name(&pdev->dev), sai); if (ret) { dev_err(&pdev->dev, "irq request returned %d\n", ret); return ret; } ret = devm_snd_soc_register_component(&pdev->dev, &stm32_component, sai->cpu_dai_drv, 1); if (ret) return ret; ret = devm_snd_dmaengine_pcm_register(&pdev->dev, &stm32_sai_pcm_config, 0); if (ret) { dev_err(&pdev->dev, "could not register pcm dma\n"); return ret; } return 0; }
static int lm4857_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct regmap *regmap; regmap = devm_regmap_init_i2c(i2c, &lm4857_regmap_config); if (IS_ERR(regmap)) return PTR_ERR(regmap); return devm_snd_soc_register_component(&i2c->dev, &lm4857_component_driver, NULL, 0); }
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 asoc_dmic_probe(struct platform_device *pdev) { struct omap_dmic *dmic; struct resource *res; int ret; dmic = devm_kzalloc(&pdev->dev, sizeof(struct omap_dmic), GFP_KERNEL); if (!dmic) return -ENOMEM; platform_set_drvdata(pdev, dmic); dmic->dev = &pdev->dev; dmic->sysclk = OMAP_DMIC_SYSCLK_SYNC_MUX_CLKS; mutex_init(&dmic->mutex); dmic->fclk = devm_clk_get(dmic->dev, "fck"); if (IS_ERR(dmic->fclk)) { dev_err(dmic->dev, "cant get fck\n"); return -ENODEV; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dma"); if (!res) { dev_err(dmic->dev, "invalid dma memory resource\n"); return -ENODEV; } dmic->dma_data.addr = res->start + OMAP_DMIC_DATA_REG; dmic->dma_data.filter_data = "up_link"; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mpu"); dmic->io_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(dmic->io_base)) return PTR_ERR(dmic->io_base); ret = devm_snd_soc_register_component(&pdev->dev, &omap_dmic_component, &omap_dmic_dai, 1); if (ret) return ret; ret = omap_pcm_platform_register(&pdev->dev); if (ret) return ret; return 0; }
static int asoc_mcbsp_probe(struct platform_device *pdev) { struct omap_mcbsp_platform_data *pdata = dev_get_platdata(&pdev->dev); struct omap_mcbsp *mcbsp; const struct of_device_id *match; int ret; match = of_match_device(omap_mcbsp_of_match, &pdev->dev); if (match) { struct device_node *node = pdev->dev.of_node; struct omap_mcbsp_platform_data *pdata_quirk = pdata; int buffer_size; pdata = devm_kzalloc(&pdev->dev, sizeof(struct omap_mcbsp_platform_data), GFP_KERNEL); if (!pdata) return -ENOMEM; memcpy(pdata, match->data, sizeof(*pdata)); if (!of_property_read_u32(node, "ti,buffer-size", &buffer_size)) pdata->buffer_size = buffer_size; if (pdata_quirk) pdata->force_ick_on = pdata_quirk->force_ick_on; } else if (!pdata) { dev_err(&pdev->dev, "missing platform data.\n"); return -EINVAL; } mcbsp = devm_kzalloc(&pdev->dev, sizeof(struct omap_mcbsp), GFP_KERNEL); if (!mcbsp) return -ENOMEM; mcbsp->id = pdev->id; mcbsp->pdata = pdata; mcbsp->dev = &pdev->dev; platform_set_drvdata(pdev, mcbsp); ret = omap_mcbsp_init(pdev); if (ret) return ret; ret = devm_snd_soc_register_component(&pdev->dev, &omap_mcbsp_component, &omap_mcbsp_dai, 1); if (ret) return ret; return omap_pcm_platform_register(&pdev->dev); }
static int hi6210_i2s_probe(struct platform_device *pdev) { struct device_node *node = pdev->dev.of_node; struct device *dev = &pdev->dev; struct hi6210_i2s *i2s; struct resource *res; int ret; i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL); if (!i2s) return -ENOMEM; i2s->dev = dev; spin_lock_init(&i2s->lock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2s->base = devm_ioremap_resource(dev, res); if (IS_ERR(i2s->base)) return PTR_ERR(i2s->base); i2s->base_phys = (phys_addr_t)res->start; i2s->dai = hi6210_i2s_dai_init; dev_set_drvdata(&pdev->dev, i2s); i2s->sysctrl = syscon_regmap_lookup_by_phandle(node, "hisilicon,sysctrl-syscon"); if (IS_ERR(i2s->sysctrl)) return PTR_ERR(i2s->sysctrl); i2s->clk[CLK_DACODEC] = devm_clk_get(&pdev->dev, "dacodec"); if (IS_ERR_OR_NULL(i2s->clk[CLK_DACODEC])) return PTR_ERR(i2s->clk[CLK_DACODEC]); i2s->clocks++; i2s->clk[CLK_I2S_BASE] = devm_clk_get(&pdev->dev, "i2s-base"); if (IS_ERR_OR_NULL(i2s->clk[CLK_I2S_BASE])) return PTR_ERR(i2s->clk[CLK_I2S_BASE]); i2s->clocks++; ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); if (ret) return ret; ret = devm_snd_soc_register_component(&pdev->dev, &hi6210_i2s_i2s_comp, &i2s->dai, 1); return ret; }
static int wm9712_probe(struct platform_device *pdev) { struct wm9712_priv *wm9712; wm9712 = devm_kzalloc(&pdev->dev, sizeof(*wm9712), GFP_KERNEL); if (wm9712 == NULL) return -ENOMEM; mutex_init(&wm9712->lock); wm9712->mfd_pdata = dev_get_platdata(&pdev->dev); platform_set_drvdata(pdev, wm9712); return devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_wm9712, wm9712_dai, ARRAY_SIZE(wm9712_dai)); }
static int asoc_mmp_sspa_probe(struct platform_device *pdev) { struct sspa_priv *priv; struct resource *res; priv = devm_kzalloc(&pdev->dev, sizeof(struct sspa_priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->sspa = devm_kzalloc(&pdev->dev, sizeof(struct ssp_device), GFP_KERNEL); if (priv->sspa == NULL) return -ENOMEM; priv->dma_params = devm_kzalloc(&pdev->dev, 2 * sizeof(struct snd_dmaengine_dai_dma_data), GFP_KERNEL); if (priv->dma_params == NULL) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->sspa->mmio_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(priv->sspa->mmio_base)) return PTR_ERR(priv->sspa->mmio_base); priv->sspa->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(priv->sspa->clk)) return PTR_ERR(priv->sspa->clk); priv->audio_clk = clk_get(NULL, "mmp-audio"); if (IS_ERR(priv->audio_clk)) return PTR_ERR(priv->audio_clk); priv->sysclk = clk_get(NULL, "mmp-sysclk"); if (IS_ERR(priv->sysclk)) { clk_put(priv->audio_clk); return PTR_ERR(priv->sysclk); } clk_enable(priv->audio_clk); priv->dai_fmt = (unsigned int) -1; platform_set_drvdata(pdev, priv); return devm_snd_soc_register_component(&pdev->dev, &mmp_sspa_component, &mmp_sspa_dai, 1); }
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; }
static int max9877_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct regmap *regmap; int i; regmap = devm_regmap_init_i2c(client, &max9877_regmap); if (IS_ERR(regmap)) return PTR_ERR(regmap); /* Ensure the device is in reset state */ for (i = 0; i < ARRAY_SIZE(max9877_regs); i++) regmap_write(regmap, max9877_regs[i].reg, max9877_regs[i].def); return devm_snd_soc_register_component(&client->dev, &max9877_component_driver, NULL, 0); }
static int ak4642_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct device *dev = &i2c->dev; struct device_node *np = dev->of_node; const struct ak4642_drvdata *drvdata = NULL; struct regmap *regmap; struct ak4642_priv *priv; struct clk *mcko = NULL; if (np) { const struct of_device_id *of_id; mcko = ak4642_of_parse_mcko(dev); if (IS_ERR(mcko)) mcko = NULL; of_id = of_match_device(ak4642_of_match, dev); if (of_id) drvdata = of_id->data; } else { drvdata = (const struct ak4642_drvdata *)id->driver_data; } if (!drvdata) { dev_err(dev, "Unknown device type\n"); return -EINVAL; } priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->drvdata = drvdata; priv->mcko = mcko; i2c_set_clientdata(i2c, priv); regmap = devm_regmap_init_i2c(i2c, drvdata->regmap_config); if (IS_ERR(regmap)) return PTR_ERR(regmap); return devm_snd_soc_register_component(dev, &soc_component_dev_ak4642, &ak4642_dai, 1); }
static int fsl_sai_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct fsl_sai *sai; struct resource *res; void __iomem *base; int ret; sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL); if (!sai) return -ENOMEM; sai->big_endian_regs = of_property_read_bool(np, "big-endian-regs"); if (sai->big_endian_regs) fsl_sai_regmap_config.val_format_endian = REGMAP_ENDIAN_BIG; sai->big_endian_data = of_property_read_bool(np, "big-endian-data"); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(base)) return PTR_ERR(base); sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "sai", base, &fsl_sai_regmap_config); if (IS_ERR(sai->regmap)) { dev_err(&pdev->dev, "regmap init failed\n"); return PTR_ERR(sai->regmap); } sai->dma_params_rx.addr = res->start + FSL_SAI_RDR; sai->dma_params_tx.addr = res->start + FSL_SAI_TDR; sai->dma_params_rx.maxburst = FSL_SAI_MAXBURST_RX; sai->dma_params_tx.maxburst = FSL_SAI_MAXBURST_TX; platform_set_drvdata(pdev, sai); ret = devm_snd_soc_register_component(&pdev->dev, &fsl_component, &fsl_sai_dai, 1); if (ret) return ret; return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, SND_DMAENGINE_PCM_FLAG_NO_RESIDUE); }
static int sirf_usp_pcm_probe(struct platform_device *pdev) { int ret; struct sirf_usp *usp; void __iomem *base; struct resource *mem_res; usp = devm_kzalloc(&pdev->dev, sizeof(struct sirf_usp), GFP_KERNEL); if (!usp) return -ENOMEM; platform_set_drvdata(pdev, usp); mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); base = devm_ioremap(&pdev->dev, mem_res->start, resource_size(mem_res)); if (base == NULL) return -ENOMEM; usp->regmap = devm_regmap_init_mmio(&pdev->dev, base, &sirf_usp_regmap_config); if (IS_ERR(usp->regmap)) return PTR_ERR(usp->regmap); usp->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(usp->clk)) { dev_err(&pdev->dev, "Get clock failed.\n"); return PTR_ERR(usp->clk); } pm_runtime_enable(&pdev->dev); if (!pm_runtime_enabled(&pdev->dev)) { ret = sirf_usp_pcm_runtime_resume(&pdev->dev); if (ret) return ret; } ret = devm_snd_soc_register_component(&pdev->dev, &sirf_usp_component, &sirf_usp_pcm_dai, 1); if (ret) { dev_err(&pdev->dev, "Register Audio SoC dai failed.\n"); return ret; } return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); }
static int ak4613_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct device *dev = &i2c->dev; struct device_node *np = dev->of_node; const struct regmap_config *regmap_cfg; struct regmap *regmap; struct ak4613_priv *priv; regmap_cfg = NULL; if (np) { const struct of_device_id *of_id; of_id = of_match_device(ak4613_of_match, dev); if (of_id) regmap_cfg = of_id->data; } else { regmap_cfg = (const struct regmap_config *)id->driver_data; } if (!regmap_cfg) return -EINVAL; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; ak4613_parse_of(priv, dev); priv->iface = NULL; priv->cnt = 0; priv->sysclk = 0; INIT_WORK(&priv->dummy_write_work, ak4613_dummy_write); mutex_init(&priv->lock); i2c_set_clientdata(i2c, priv); regmap = devm_regmap_init_i2c(i2c, regmap_cfg); if (IS_ERR(regmap)) return PTR_ERR(regmap); return devm_snd_soc_register_component(dev, &soc_component_dev_ak4613, &ak4613_dai, 1); }
static int sirf_audio_port_probe(struct platform_device *pdev) { int ret; struct sirf_audio_port *port; port = devm_kzalloc(&pdev->dev, sizeof(struct sirf_audio_port), GFP_KERNEL); if (!port) return -ENOMEM; ret = devm_snd_soc_register_component(&pdev->dev, &sirf_audio_port_component, &sirf_audio_port_dai, 1); if (ret) return ret; platform_set_drvdata(pdev, port); return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); }
static int stm32_i2s_probe(struct platform_device *pdev) { struct stm32_i2s_data *i2s; int ret; i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL); if (!i2s) return -ENOMEM; ret = stm32_i2s_parse_dt(pdev, i2s); if (ret) return ret; i2s->pdev = pdev; i2s->ms_flg = I2S_MS_NOT_SET; spin_lock_init(&i2s->lock_fd); spin_lock_init(&i2s->irq_lock); platform_set_drvdata(pdev, i2s); ret = stm32_i2s_dais_init(pdev, i2s); if (ret) return ret; i2s->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "pclk", i2s->base, i2s->regmap_conf); if (IS_ERR(i2s->regmap)) { dev_err(&pdev->dev, "regmap init failed\n"); return PTR_ERR(i2s->regmap); } ret = devm_snd_soc_register_component(&pdev->dev, &stm32_i2s_component, i2s->dai_drv, 1); if (ret) return ret; ret = devm_snd_dmaengine_pcm_register(&pdev->dev, &stm32_i2s_pcm_config, 0); if (ret) return ret; /* Set SPI/I2S in i2s mode */ return regmap_update_bits(i2s->regmap, STM32_I2S_CGFR_REG, I2S_CGFR_I2SMOD, I2S_CGFR_I2SMOD); }