static int msm_dai_stub_dev_probe(struct platform_device *pdev) { int rc, id = -1; const char *stub_dev_id = "qcom,msm-dai-stub-dev-id"; rc = of_property_read_u32(pdev->dev.of_node, stub_dev_id, &id); if (rc) { dev_err(&pdev->dev, "%s: missing %s in dt node\n", __func__, stub_dev_id); return rc; } pdev->id = id; dev_set_name(&pdev->dev, "%s.%d", "msm-dai-stub-dev", id); pr_debug("%s: dev name %s, id:%d\n", __func__, dev_name(&pdev->dev), pdev->id); switch (id) { case STUB_RX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dai_rx, 1); break; case STUB_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dai_tx[0], 1); break; case STUB_1_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dai_tx[1], 1); break; case STUB_DTMF_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dtmf_tx_dai, 1); break; case STUB_HOST_RX_CAPTURE_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_host_capture_tx_dai[0], 1); break; case STUB_HOST_TX_CAPTURE_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_host_capture_tx_dai[1], 1); break; case STUB_HOST_RX_PLAYBACK_RX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_host_playback_rx_dai[0], 1); break; case STUB_HOST_TX_PLAYBACK_RX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_host_playback_rx_dai[1], 1); break; } return rc; }
static int sst_byt_pcm_dev_probe(struct platform_device *pdev) { struct sst_pdata *sst_pdata = dev_get_platdata(&pdev->dev); int ret; ret = sst_byt_dsp_init(&pdev->dev, sst_pdata); if (ret < 0) return -ENODEV; ret = snd_soc_register_platform(&pdev->dev, &byt_soc_platform); if (ret < 0) goto err_plat; ret = snd_soc_register_component(&pdev->dev, &byt_dai_component, byt_dais, ARRAY_SIZE(byt_dais)); if (ret < 0) goto err_comp; return 0; err_comp: snd_soc_unregister_platform(&pdev->dev); err_plat: sst_byt_dsp_free(&pdev->dev, sst_pdata); return ret; }
static int jz_spdif_platfrom_probe(struct platform_device *pdev){ struct jz_aic_subdev_pdata *pdata = dev_get_platdata(&pdev->dev); struct jz_spdif *jz_spdif; int i = 0, ret; jz_spdif = devm_kzalloc(&pdev->dev, sizeof(struct jz_spdif), GFP_KERNEL); if (!jz_spdif) return -ENOMEM; jz_spdif->aic = pdev->dev.parent; jz_spdif->tx_dma_data.dma_addr = pdata->dma_base + SPFIFO; platform_set_drvdata(pdev, (void *)jz_spdif); for (; i < ARRAY_SIZE(jz_spdif_sysfs_attrs); i++) { ret = device_create_file(&pdev->dev, &jz_spdif_sysfs_attrs[i]); if (ret) dev_warn(&pdev->dev,"attribute %s create failed %x", attr_name(jz_spdif_sysfs_attrs[i]), ret); } ret = snd_soc_register_component(&pdev->dev, &jz_spdif_component, &jz_spdif_dai, 1); if (!ret) dev_dbg(&pdev->dev, "spdif platform probe success\n"); return ret; }
static int pxa2xx_ac97_dev_probe(struct platform_device *pdev) { int ret; if (pdev->id != -1) { dev_err(&pdev->dev, "PXA2xx has only one AC97 port.\n"); return -ENXIO; } ret = pxa2xx_ac97_hw_probe(pdev); if (ret) { dev_err(&pdev->dev, "PXA2xx AC97 hw probe error (%d)\n", ret); return ret; } ret = snd_soc_set_ac97_ops(&pxa2xx_ac97_ops); if (ret != 0) return ret; /* Punt most of the init to the SoC probe; we may need the machine * driver to do interesting things with the clocking to get us up * and running. */ return snd_soc_register_component(&pdev->dev, &pxa_ac97_component, pxa_ac97_dai_driver, ARRAY_SIZE(pxa_ac97_dai_driver)); }
static int sst_platform_probe(struct platform_device *pdev) { struct sst_data *sst; int ret; struct sst_platform_data *pdata = pdev->dev.platform_data; pr_debug("sst_platform_probe called\n"); sst = devm_kzalloc(&pdev->dev, sizeof(*sst), GFP_KERNEL); if (sst == NULL) { pr_err("kzalloc failed\n"); return -ENOMEM; } sst_pdev = &pdev->dev; sst->pdata = pdata; mutex_init(&sst->lock); dev_set_drvdata(&pdev->dev, sst); ret = snd_soc_register_platform(&pdev->dev, &sst_soc_platform_drv); if (ret) { pr_err("registering soc platform failed\n"); return ret; } ret = snd_soc_register_component(&pdev->dev, &pcm_component, sst_platform_dai, ARRAY_SIZE(sst_platform_dai)); if (ret) { pr_err("registering cpu dais failed\n"); snd_soc_unregister_platform(&pdev->dev); } return ret; }
static int asoc_ssc_init(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct ssc_device *ssc = platform_get_drvdata(pdev); int ret; ret = snd_soc_register_component(dev, &atmel_ssc_component, &atmel_ssc_dai, 1); if (ret) { dev_err(dev, "Could not register DAI: %d\n", ret); goto err; } if (ssc->pdata->use_dma) ret = atmel_pcm_dma_platform_register(dev); else ret = atmel_pcm_pdc_platform_register(dev); if (ret) { dev_err(dev, "Could not register PCM: %d\n", ret); goto err_unregister_dai; } return 0; err_unregister_dai: snd_soc_unregister_component(dev); err: return ret; }
SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000), .formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE),}, .capture = {
/* To do: change to register DAIs as batch */ static int msm_dai_q6_hdmi_dev_probe(struct platform_device *pdev) { int rc, id; const char *q6_dev_id = "qcom,msm-dai-q6-dev-id"; rc = of_property_read_u32(pdev->dev.of_node, q6_dev_id, &id); if (rc) { dev_err(&pdev->dev, "%s: missing %s in dt node\n", __func__, q6_dev_id); return rc; } pdev->id = id; dev_set_name(&pdev->dev, "%s.%d", "msm-dai-q6-hdmi", id); pr_debug("%s: dev name %s, id:%d\n", __func__, dev_name(&pdev->dev), pdev->id); switch (pdev->id) { case HDMI_RX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_hdmi_q6_component, &msm_dai_q6_hdmi_hdmi_rx_dai, 1); break; default: dev_err(&pdev->dev, "invalid device ID %d\n", pdev->id); rc = -ENODEV; break; } return rc; }
static int ath79_i2s_drv_probe(struct platform_device *pdev) { printk("%s\n", __FUNCTION__); spin_lock_init(&ath79_stereo_lock); ath79_stereo_reset(); return snd_soc_register_component(&pdev->dev, &ath79_i2s_component, &ath79_i2s_dai, 1); }
static int msm_fe_dai_dev_probe(struct platform_device *pdev) { dev_dbg(&pdev->dev, "%s: dev name %s\n", __func__, dev_name(&pdev->dev)); return snd_soc_register_component(&pdev->dev, &msm_fe_dai_component, msm_fe_dais, ARRAY_SIZE(msm_fe_dais)); }
static int jz_dmic_platfrom_probe(struct platform_device *pdev) { struct jz_dmic *jz_dmic; struct resource *res = NULL; int i = 0, ret; jz_dmic = devm_kzalloc(&pdev->dev, sizeof(struct jz_dmic), GFP_KERNEL); if (!jz_dmic) return -ENOMEM; jz_dmic->dev = &pdev->dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENOENT; if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res),pdev->name)) return -EBUSY; jz_dmic->res_start = res->start; jz_dmic->res_size = resource_size(res); jz_dmic->vaddr_base = devm_ioremap_nocache(&pdev->dev, jz_dmic->res_start, jz_dmic->res_size); if (!jz_dmic->vaddr_base) { dev_err(&pdev->dev, "Failed to ioremap mmio memory\n"); return -ENOMEM; } jz_dmic->dmic_mode = 0; jz_dmic->rx_dma_data.dma_addr = (dma_addr_t)jz_dmic->res_start + DMICDR; jz_dmic->vcc_dmic = regulator_get(&pdev->dev,"vcc_dmic"); platform_set_drvdata(pdev, (void *)jz_dmic); for (; i < ARRAY_SIZE(jz_dmic_sysfs_attrs); i++) { ret = device_create_file(&pdev->dev, &jz_dmic_sysfs_attrs[i]); if (ret) dev_warn(&pdev->dev,"attribute %s create failed %x", attr_name(jz_dmic_sysfs_attrs[i]), ret); } jz_dmic->clk_gate_dmic = clk_get(&pdev->dev, "dmic"); if (IS_ERR_OR_NULL(jz_dmic->clk_gate_dmic)) { ret = PTR_ERR(jz_dmic->clk_gate_dmic); jz_dmic->clk_gate_dmic = NULL; dev_err(&pdev->dev, "Failed to get clock: %d\n", ret); return ret; } ret = snd_soc_register_component(&pdev->dev, &jz_dmic_component, &jz_dmic_dai, 1); if (ret) goto err_register_cpu_dai; dev_dbg(&pdev->dev, "dmic platform probe success\n"); return ret; err_register_cpu_dai: platform_set_drvdata(pdev, NULL); return ret; }
static int au1xac97c_drvprobe(struct platform_device *pdev) { int ret; struct resource *iores, *dmares; struct au1xpsc_audio_data *ctx; ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; mutex_init(&ctx->lock); iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!iores) return -ENODEV; if (!devm_request_mem_region(&pdev->dev, iores->start, resource_size(iores), pdev->name)) return -EBUSY; ctx->mmio = devm_ioremap_nocache(&pdev->dev, iores->start, resource_size(iores)); if (!ctx->mmio) return -EBUSY; dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0); if (!dmares) return -EBUSY; ctx->dmaids[SNDRV_PCM_STREAM_PLAYBACK] = dmares->start; dmares = platform_get_resource(pdev, IORESOURCE_DMA, 1); if (!dmares) return -EBUSY; ctx->dmaids[SNDRV_PCM_STREAM_CAPTURE] = dmares->start; /* switch it on */ WR(ctx, AC97_ENABLE, EN_D | EN_CE); WR(ctx, AC97_ENABLE, EN_CE); ctx->cfg = CFG_RC(3) | CFG_XS(3); WR(ctx, AC97_CONFIG, ctx->cfg); platform_set_drvdata(pdev, ctx); ret = snd_soc_set_ac97_ops(&ac97c_bus_ops); if (ret) return ret; ret = snd_soc_register_component(&pdev->dev, &au1xac97c_component, &au1xac97c_dai_driver, 1); if (ret) return ret; ac97c_workdata = ctx; return 0; }
static int msm_dai_stub_dev_probe(struct platform_device *pdev) { int rc, id = -1; const char *stub_dev_id = "qcom,msm-dai-stub-dev-id"; rc = of_property_read_u32(pdev->dev.of_node, stub_dev_id, &id); if (rc) { dev_err(&pdev->dev, "%s: missing %s in dt node\n", __func__, stub_dev_id); return rc; } pdev->id = id; dev_set_name(&pdev->dev, "%s.%d", "msm-dai-stub-dev", id); pr_debug("%s: dev name %s, id:%d\n", __func__, dev_name(&pdev->dev), pdev->id); switch (id) { case STUB_RX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dai_rx, 1); break; case STUB_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dai_tx[0], 1); break; case STUB_1_TX: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_stub_dai_tx[1], 1); case TFA9890_LEFT_STUB: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_tfa9890_stub_dai_rx[0], 1); break; case TFA9890_RIGHT_STUB: rc = snd_soc_register_component(&pdev->dev, &msm_dai_stub_component, &msm_dai_tfa9890_stub_dai_rx[1], 1); break; } return rc; }
/* To do: change to register DAIs as batch */ static int msm_dai_q6_hdmi_dev_probe(struct platform_device *pdev) { int rc = 0; dev_info(&pdev->dev, "dev name %s dev-id %d\n", dev_name(&pdev->dev), pdev->id); rc = snd_soc_register_component(&pdev->dev, &msm_hdmi_q6_component, &msm_dai_q6_hdmi_hdmi_rx_dai, 1); return rc; }
static int au1xpsc_i2s_drvprobe(struct platform_device *pdev) { struct resource *iores, *dmares; unsigned long sel; struct au1xpsc_audio_data *wd; wd = devm_kzalloc(&pdev->dev, sizeof(struct au1xpsc_audio_data), GFP_KERNEL); if (!wd) return -ENOMEM; iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); wd->mmio = devm_ioremap_resource(&pdev->dev, iores); if (IS_ERR(wd->mmio)) return PTR_ERR(wd->mmio); dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0); if (!dmares) return -EBUSY; wd->dmaids[SNDRV_PCM_STREAM_PLAYBACK] = dmares->start; dmares = platform_get_resource(pdev, IORESOURCE_DMA, 1); if (!dmares) return -EBUSY; wd->dmaids[SNDRV_PCM_STREAM_CAPTURE] = dmares->start; /* preserve PSC clock source set up by platform (dev.platform_data * is already occupied by soc layer) */ sel = __raw_readl(PSC_SEL(wd)) & PSC_SEL_CLK_MASK; __raw_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd)); wmb(); /* drain writebuffer */ __raw_writel(PSC_SEL_PS_I2SMODE | sel, PSC_SEL(wd)); __raw_writel(0, I2S_CFG(wd)); wmb(); /* drain writebuffer */ /* preconfigure: set max rx/tx fifo depths */ wd->cfg |= PSC_I2SCFG_RT_FIFO8 | PSC_I2SCFG_TT_FIFO8; /* don't wait for I2S core to become ready now; clocks may not * be running yet; depending on clock input for PSC a wait might * time out. */ /* name the DAI like this device instance ("au1xpsc-i2s.PSCINDEX") */ memcpy(&wd->dai_drv, &au1xpsc_i2s_dai_template, sizeof(struct snd_soc_dai_driver)); wd->dai_drv.name = dev_name(&pdev->dev); platform_set_drvdata(pdev, wd); return snd_soc_register_component(&pdev->dev, &au1xpsc_i2s_component, &wd->dai_drv, 1); }
static int spdif_out_probe(struct platform_device *pdev) { struct spdif_out_dev *host; struct spear_spdif_platform_data *pdata; struct resource *res; int ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res), pdev->name)) { dev_warn(&pdev->dev, "Failed to get memory resourse\n"); return -ENOENT; } host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL); if (!host) { dev_warn(&pdev->dev, "kzalloc fail\n"); return -ENOMEM; } host->io_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!host->io_base) { dev_warn(&pdev->dev, "ioremap failed\n"); return -ENOMEM; } host->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(host->clk)) return PTR_ERR(host->clk); pdata = dev_get_platdata(&pdev->dev); host->dma_params.data = pdata->dma_params; host->dma_params.addr = res->start + SPDIF_OUT_FIFO_DATA; host->dma_params.max_burst = 16; host->dma_params.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; host->dma_params.filter = pdata->filter; dev_set_drvdata(&pdev->dev, host); ret = snd_soc_register_component(&pdev->dev, &spdif_out_component, &spdif_out_dai, 1); if (ret != 0) { clk_put(host->clk); return ret; } return 0; }
static int rt5350_pcm_dev_probe(struct platform_device *pdev) { struct rt5350_pcm *pcm; int ret; snd_dmaengine_pcm_register(&pdev->dev, &rt5350_dmaengine_pcm_config, SND_DMAENGINE_PCM_FLAG_COMPAT); pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); if (!pcm) return -ENOMEM; pcm->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!pcm->mem) { ret = -ENOENT; goto err_free; } pcm->mem = request_mem_region(pcm->mem->start, resource_size(pcm->mem), pdev->name); if (!pcm->mem) { ret = -EBUSY; goto err_free; } pcm->base = ioremap_nocache(pcm->mem->start, resource_size(pcm->mem)); if (!pcm->base) { ret = -EBUSY; goto err_release_mem_region; } pcm->phys_base = pcm->mem->start; platform_set_drvdata(pdev, pcm); ret = snd_soc_register_component(&pdev->dev, &rt5350_pcm_component, &rt5350_pcm_dai, 1); if (!ret) { dev_err(&pdev->dev, "loaded\n"); return ret; } dev_err(&pdev->dev, "Failed to register DAI\n"); iounmap(pcm->base); err_release_mem_region: release_mem_region(pcm->mem->start, resource_size(pcm->mem)); err_free: kfree(pcm); return ret; }
/* --------------------------------------------------------------------- * OF platform bus binding code: * - Probe/remove operations * - OF device match table */ static int psc_i2s_of_probe(struct platform_device *op) { int rc; struct psc_dma *psc_dma; struct mpc52xx_psc __iomem *regs; rc = mpc5200_audio_dma_create(op); if (rc != 0) return rc; rc = snd_soc_register_component(&op->dev, &psc_i2s_component, psc_i2s_dai, ARRAY_SIZE(psc_i2s_dai)); if (rc != 0) { pr_err("Failed to register DAI\n"); return rc; } psc_dma = dev_get_drvdata(&op->dev); regs = psc_dma->psc_regs; /* Configure the serial interface mode; defaulting to CODEC8 mode */ psc_dma->sicr = MPC52xx_PSC_SICR_DTS1 | MPC52xx_PSC_SICR_I2S | MPC52xx_PSC_SICR_CLKPOL; out_be32(&psc_dma->psc_regs->sicr, psc_dma->sicr | MPC52xx_PSC_SICR_SIM_CODEC_8); /* Check for the codec handle. If it is not present then we * are done */ if (!of_get_property(op->dev.of_node, "codec-handle", NULL)) return 0; /* Due to errata in the dma mode; need to line up enabling * the transmitter with a transition on the frame sync * line */ /* first make sure it is low */ while ((in_8(®s->ipcr_acr.ipcr) & 0x80) != 0) ; /* then wait for the transition to high */ while ((in_8(®s->ipcr_acr.ipcr) & 0x80) == 0) ; /* Finally, enable the PSC. * Receiver must always be enabled; even when we only want * transmit. (see 15.3.2.3 of MPC5200B User's Guide) */ /* Go */ out_8(&psc_dma->psc_regs->command, MPC52xx_PSC_TX_ENABLE | MPC52xx_PSC_RX_ENABLE); return 0; }
static int tegra_soc_platform_probe(struct platform_device *pdev) { int ret = 0; tegra_pcm_platform_register(&pdev->dev); ret = snd_soc_register_component(&pdev->dev, &tegra_fast_pcm_component, tegra_fast_dai, ARRAY_SIZE(tegra_fast_dai)); if (ret) dev_err(&pdev->dev, "Could not register component: %d\n", ret); return 0; }
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 = 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"); ret = -ENODEV; goto err_put_clk; } 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)) { ret = PTR_ERR(dmic->io_base); goto err_put_clk; } ret = snd_soc_register_component(&pdev->dev, &omap_dmic_component, &omap_dmic_dai, 1); if (ret) goto err_put_clk; return 0; err_put_clk: clk_put(dmic->fclk); return ret; }
static int mtk_routing_dev_probe(struct platform_device *pdev) { int rc = 0; pr_debug("mtk_routing_dev_probe name %s\n", dev_name(&pdev->dev)); if (pdev->dev.of_node) { dev_set_name(&pdev->dev, "%s", MT_SOC_ROUTING_DAI_NAME); } pr_debug("%s: dev name %s\n", __func__, dev_name(&pdev->dev)); rc = snd_soc_register_component(&pdev->dev, &dai_routing_component, mtk_routing_dai, ARRAY_SIZE(mtk_routing_dai)); return rc; }
static int sprd_vaudio_drv_probe(struct platform_device *pdev) { int ret; sp_asoc_pr_dbg("%s\n", __func__); ret = snd_soc_register_component(&pdev->dev, &sprd_vaudio_component, sprd_vaudio_dai, ARRAY_SIZE(sprd_vaudio_dai)); sp_asoc_pr_dbg("return %i\n", ret); return ret; }
static int mtk_dai_stub_dev_probe(struct platform_device *pdev) { int rc = 0; printk("mtk_dai_stub_dev_probe name %s\n", dev_name(&pdev->dev)); if (pdev->dev.of_node) { dev_set_name(&pdev->dev, "%s", MT_SOC_DAI_NAME); } printk("%s: dev name %s\n", __func__, dev_name(&pdev->dev)); rc = snd_soc_register_component(&pdev->dev, &mt_dai_component, mtk_dai_stub_dai, ARRAY_SIZE(mtk_dai_stub_dai)); printk("%s: rc = %d\n", __func__, rc); return rc; }
static int mtk_routing_dev_probe(struct platform_device *pdev) { int rc = 0; pr_warn("mtk_routing_dev_probe name %s\n", dev_name(&pdev->dev)); pdev->dev.coherent_dma_mask = DMA_BIT_MASK(64); if (pdev->dev.dma_mask == NULL) pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; if (pdev->dev.of_node) dev_set_name(&pdev->dev, "%s", MT_SOC_ROUTING_DAI_NAME); pr_warn("%s: dev name %s\n", __func__, dev_name(&pdev->dev)); rc = snd_soc_register_component(&pdev->dev, &dai_routing_component, mtk_routing_dai, ARRAY_SIZE(mtk_routing_dai)); return rc; }
static int sst_platform_probe(struct platform_device *pdev) { int ret; pr_debug("sst_platform_probe called\n"); sst = NULL; ret = snd_soc_register_platform(&pdev->dev, &sst_soc_platform_drv); if (ret) { pr_err("registering soc platform failed\n"); return ret; } ret = snd_soc_register_component(&pdev->dev, &sst_component, sst_platform_dai, ARRAY_SIZE(sst_platform_dai)); if (ret) { pr_err("registering cpu dais failed\n"); snd_soc_unregister_platform(&pdev->dev); } return ret; }
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; 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; } 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 snd_soc_register_component(&pdev->dev, &omap_mcbsp_component, &omap_mcbsp_dai, 1); return ret; }
/** * devm_snd_soc_register_component - resource managed component registration * @dev: Device used to manage component * @cmpnt_drv: Component driver * @dai_drv: DAI driver * @num_dai: Number of DAIs to register * * Register a component with automatic unregistration when the device is * unregistered. */ int devm_snd_soc_register_component(struct device *dev, const struct snd_soc_component_driver *cmpnt_drv, struct snd_soc_dai_driver *dai_drv, int num_dai) { struct device **ptr; int ret; ptr = devres_alloc(devm_component_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return -ENOMEM; ret = snd_soc_register_component(dev, cmpnt_drv, dai_drv, num_dai); if (ret == 0) { *ptr = dev; devres_add(dev, ptr); } else { devres_free(ptr); } return ret; }
static int asoc_mcpdm_probe(struct platform_device *pdev) { struct omap_mcpdm *mcpdm; struct resource *res; mcpdm = devm_kzalloc(&pdev->dev, sizeof(struct omap_mcpdm), GFP_KERNEL); if (!mcpdm) return -ENOMEM; platform_set_drvdata(pdev, mcpdm); mutex_init(&mcpdm->mutex); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dma"); if (res == NULL) return -ENOMEM; mcpdm->dma_data[0].addr = res->start + MCPDM_REG_DN_DATA; mcpdm->dma_data[1].addr = res->start + MCPDM_REG_UP_DATA; mcpdm->dma_data[0].filter_data = "dn_link"; mcpdm->dma_data[1].filter_data = "up_link"; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mpu"); if (res == NULL) return -ENOMEM; mcpdm->io_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(mcpdm->io_base)) return PTR_ERR(mcpdm->io_base); mcpdm->irq = platform_get_irq(pdev, 0); if (mcpdm->irq < 0) return mcpdm->irq; mcpdm->dev = &pdev->dev; return snd_soc_register_component(&pdev->dev, &omap_mcpdm_component, &omap_mcpdm_dai, 1); }
static int bf5xx_i2s_probe(struct platform_device *pdev) { struct sport_device *sport_handle; int ret; /* configure SPORT for I2S */ sport_handle = sport_init(pdev, 4, 2 * sizeof(u32), sizeof(struct bf5xx_i2s_port)); if (!sport_handle) return -ENODEV; /* register with the ASoC layers */ ret = snd_soc_register_component(&pdev->dev, &bf5xx_i2s_component, &bf5xx_i2s_dai, 1); if (ret) { pr_err("Failed to register DAI: %d\n", ret); sport_done(sport_handle); return ret; } return 0; }
static int bfin_i2s_probe(struct platform_device *pdev) { struct sport_device *sport; struct device *dev = &pdev->dev; int ret; sport = sport_create(pdev); if (!sport) return -ENODEV; /* register with the ASoC layers */ ret = snd_soc_register_component(dev, &bfin_i2s_component, &bfin_i2s_dai, 1); if (ret) { dev_err(dev, "Failed to register DAI: %d\n", ret); sport_delete(sport); return ret; } platform_set_drvdata(pdev, sport); return 0; }