static int ssp_dai_probe(struct platform_device *pdev) { int ret; struct workqueue_struct *ssp_dai_wq; pr_debug("SSP DAI: FCT %s enters\n", __func__); ret = snd_soc_register_platform(&pdev->dev, &soc_ssp_platform_drv); if (ret) { pr_err("registering SSP PLATFORM failed\n"); snd_soc_unregister_dai(&pdev->dev); return -EBUSY; } ret = snd_soc_register_dais(&pdev->dev, intel_ssp_platform_dai, ARRAY_SIZE(intel_ssp_platform_dai)); if (ret) { pr_err("registering cpu DAIs failed\n"); snd_soc_unregister_dai(&pdev->dev); return -EBUSY; } ssp_dai_wq = create_workqueue("ssp_transfer_data"); if (!ssp_dai_wq) { pr_err("work queue failed\n"); snd_soc_unregister_dai(&pdev->dev); return -ENOMEM; } platform_set_drvdata(pdev, ssp_dai_wq); pr_debug("SSP DAI: FCT %s leaves %d\n", __func__, ret); return ret; }
static int mtk_fmtx_probe(struct platform_device *pdev) { PRINTK_AUD_FMTX("%s \n", __func__); pdev->dev.coherent_dma_mask = DMA_BIT_MASK(64); if (!pdev->dev.dma_mask) { pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; } if (pdev->dev.of_node) { dev_set_name(&pdev->dev, "%s", MT_SOC_FM_MRGTX_PCM); } PRINTK_AUD_FMTX("%s: dev name %s\n", __func__, dev_name(&pdev->dev)); mDev = &pdev->dev; return snd_soc_register_platform(&pdev->dev, &mtk_fmtx_soc_platform); }
static int mtk_i2s0_probe(struct platform_device *pdev) { printk("%s \n", __func__); pdev->dev.coherent_dma_mask = DMA_BIT_MASK(64); if (!pdev->dev.dma_mask) { pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; } if (pdev->dev.of_node) { dev_set_name(&pdev->dev, "%s", MT_SOC_I2S0_PCM); } printk("%s: dev name %s\n", __func__, dev_name(&pdev->dev)); mDev = &pdev->dev; return snd_soc_register_platform(&pdev->dev, &mtk_i2s0_soc_platform); }
int cygnus_soc_platform_register(struct device *dev, struct cygnus_audio *cygaud) { int rc = 0; dev_dbg(dev, "%s Enter\n", __func__); rc = devm_request_irq(dev, cygaud->irq_num, cygnus_dma_irq, IRQF_SHARED, "cygnus-audio", cygaud); if (rc) { dev_err(dev, "%s request_irq error %d\n", __func__, rc); return rc; } rc = snd_soc_register_platform(dev, &cygnus_soc_platform); if (rc) { dev_err(dev, "%s failed\n", __func__); return rc; } return 0; }
static int mt_pcm_routing_dev_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct mt_pcm_routing_priv *priv; pr_debug("%s dev name %s\n", __func__, dev_name(&pdev->dev)); if (dev->of_node) { dev_set_name(dev, "%s", MT_SOC_ROUTING_PCM); pr_debug("%s set dev name %s\n", __func__, dev_name(dev)); } priv = devm_kzalloc(dev, sizeof(struct mt_pcm_routing_priv), GFP_KERNEL); if (unlikely(!priv)) { pr_err("%s failed to allocate private data\n", __func__); return -ENOMEM; } dev_set_drvdata(dev, priv); return snd_soc_register_platform(dev, &mt_pcm_routing_platform); }
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; } if (dpcm_enable == 1) { pr_info("dpcm enabled; overriding stream map\n"); pdata->pdev_strm_map = dpcm_strm_map; pdata->strm_map_size = ARRAY_SIZE(dpcm_strm_map); } 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 sst_platform_probe(struct platform_device *pdev) { struct sst_data *drv; int ret; struct sst_platform_data *pdata; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (drv == NULL) { return -ENOMEM; } pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (pdata == NULL) { return -ENOMEM; } pdata->pdev_strm_map = dpcm_strm_map; pdata->strm_map_size = ARRAY_SIZE(dpcm_strm_map); drv->pdata = pdata; drv->pdev = pdev; mutex_init(&drv->lock); dev_set_drvdata(&pdev->dev, drv); ret = snd_soc_register_platform(&pdev->dev, &sst_soc_platform_drv); if (ret) { dev_err(&pdev->dev, "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) { dev_err(&pdev->dev, "registering cpu dais failed\n"); snd_soc_unregister_platform(&pdev->dev); } return ret; }
int skl_platform_register(struct device *dev) { int ret; struct hdac_ext_bus *ebus = dev_get_drvdata(dev); struct skl *skl = ebus_to_skl(ebus); INIT_LIST_HEAD(&skl->ppl_list); ret = snd_soc_register_platform(dev, &skl_platform_drv); if (ret) { dev_err(dev, "soc platform registration failed %d\n", ret); return ret; } ret = snd_soc_register_component(dev, &skl_component, skl_platform_dai, ARRAY_SIZE(skl_platform_dai)); if (ret) { dev_err(dev, "soc component registration failed %d\n", ret); snd_soc_unregister_platform(dev); } return ret; }
static int __init omap_soc_platform_init(void) { return snd_soc_register_platform(&omap_soc_platform); }
int asoc_compr_platform_register(struct device *dev) { return snd_soc_register_platform(dev, &samsung_compr_platform); }
static __devinit int snd_soc_dummy_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &dummy_platform); }
static __devinit int omap_pcm_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &omap_soc_platform); }
static int mt76xx_platform_drv_probe(struct platform_device *pdev) { //printk("******* %s *******\n", __func__); return snd_soc_register_platform(&pdev->dev, &mt76xx_soc_platform); }
static int __devinit davinci_soc_platform_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &davinci_soc_platform); }
static int __init s3c_soc_platform_init(void) { return snd_soc_register_platform(&s3c24xx_soc_platform); }
static int __init sun4i_soc_platform_hdmiaudio_init(void) { return snd_soc_register_platform(&sun4i_soc_platform_hdmiaudio); }
static int __devinit samsung_asoc_platform_probe(struct platform_device *pdev) { atomic_set(&dram_usage_cnt, 0); return snd_soc_register_platform(&pdev->dev, &samsung_asoc_platform); }
static int __devinit sun7i_spdif_pcm_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &sun7i_soc_platform); }
static int kirkwood_i2s_dev_probe(struct platform_device *pdev) { struct kirkwood_asoc_platform_data *data = pdev->dev.platform_data; struct snd_soc_dai_driver *soc_dai = kirkwood_i2s_dai; struct kirkwood_dma_data *priv; struct resource *mem; struct device_node *np = pdev->dev.of_node; int err; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) { dev_err(&pdev->dev, "allocation failed\n"); return -ENOMEM; } dev_set_drvdata(&pdev->dev, priv); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->io = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(priv->io)) return PTR_ERR(priv->io); priv->irq = platform_get_irq(pdev, 0); if (priv->irq <= 0) { dev_err(&pdev->dev, "platform_get_irq failed\n"); return -ENXIO; } if (np) { priv->burst = 128; /* might be 32 or 128 */ } else if (data) { priv->burst = data->burst; } else { dev_err(&pdev->dev, "no DT nor platform data ?!\n"); return -EINVAL; } priv->clk = devm_clk_get(&pdev->dev, np ? "internal" : NULL); if (IS_ERR(priv->clk)) { dev_err(&pdev->dev, "no clock\n"); return PTR_ERR(priv->clk); } err = clk_prepare_enable(priv->clk); if (err < 0) return err; priv->extclk = devm_clk_get(&pdev->dev, "extclk"); if (IS_ERR(priv->extclk)) { if (PTR_ERR(priv->extclk) == -EPROBE_DEFER) return -EPROBE_DEFER; } else { if (priv->extclk == priv->clk) { devm_clk_put(&pdev->dev, priv->extclk); priv->extclk = ERR_PTR(-EINVAL); } else { dev_info(&pdev->dev, "found external clock\n"); clk_prepare_enable(priv->extclk); soc_dai = kirkwood_i2s_dai_extclk; } } /* Some sensible defaults - this reflects the powerup values */ priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24; priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24; /* Select the burst size */ if (priv->burst == 32) { priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32; priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32; } else { priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128; priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128; } err = snd_soc_register_component(&pdev->dev, &kirkwood_i2s_component, soc_dai, 2); if (err) { dev_err(&pdev->dev, "snd_soc_register_component failed\n"); goto err_component; } err = snd_soc_register_platform(&pdev->dev, &kirkwood_soc_platform); if (err) { dev_err(&pdev->dev, "snd_soc_register_platform failed\n"); goto err_platform; } kirkwood_i2s_init(priv); return 0; err_platform: snd_soc_unregister_component(&pdev->dev); err_component: if (!IS_ERR(priv->extclk)) clk_disable_unprepare(priv->extclk); clk_disable_unprepare(priv->clk); return err; }
static int __init socle_soc_platform_init(void) { return snd_soc_register_platform(&socle_snd_soc_platform); }
static int __init mt76xx_pcm_init(void) { printk("******* %s *******\n", __func__); return snd_soc_register_platform(&mt76xx_soc_platform); }
static __devinit int msm_pcm_probe(struct platform_device *pdev) { pr_debug("%s: dev name %s\n", __func__, dev_name(&pdev->dev)); return snd_soc_register_platform(&pdev->dev, &msm_soc_platform); }
static int __init s5p_soc_platform_init(void) { return snd_soc_register_platform(&idma_soc_platform); }
static int bfin_i2s_soc_platform_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &bf5xx_i2s_soc_platform); }
static int __devinit tegra_pcm_platform_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &tegra_pcm_platform); }
static int __init davinci_soc_platform_init(void) { return snd_soc_register_platform(&davinci_soc_platform); }
static int __devinit samsung_asoc_platform_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &samsung_asoc_platform); }
static int hi3630_srcup_normal_probe(struct platform_device *pdev) { int ret = -1; struct device *dev = &pdev->dev; struct hi3630_srcup_data *pdata = NULL; if (!dev) { loge("platform_device has no device\n"); return -ENOENT; } pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { dev_err(dev, "cannot allocate hi3630 srcup platform data\n"); return -ENOMEM; } pdata->dev = dev; #ifdef SRCUP_ENABLE pdata->hi3630_asp_irq = dev_get_drvdata(pdev->dev.parent); if (!pdata->hi3630_asp_irq) { dev_err(dev, "get parent device error\n"); return -ENOENT; } pdata->irq = platform_get_irq_byname(pdev, "asp_srcup_normal"); if (0 > pdata->irq) { dev_err(dev, "cannot get irq\n"); return -ENOENT; } pdata->regu.supply = "asp-srcup-normal"; ret = devm_regulator_bulk_get(dev, 1, &(pdata->regu)); if (0 != ret) { dev_err(dev, "couldn't get regulators %d\n", ret); return -ENOENT; } pdata->hwlock = hwspin_lock_request_specific(HWLOCK_ID); if(NULL == pdata->hwlock) { dev_err(dev, "couldn't request hwlock:%d\n", HWLOCK_ID); return -ENOENT; } #ifdef CONFIG_PM_RUNTIME pm_runtime_set_autosuspend_delay(dev, 100); /* 100ms*/ pm_runtime_use_autosuspend(dev); pm_runtime_enable(dev); #endif #endif platform_set_drvdata(pdev, pdata); dev_set_name(dev, "hi3630-srcup-normal"); ret = snd_soc_register_platform(dev, &hi3630_srcup_normal_platform); if (ret) { loge("snd_soc_register_platform return %d\n", ret); return -ENODEV; } return ret; }
static int __init sunxi_daudio_pcm_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &sunxi_soc_platform); }
static int __devinit bf5xx_soc_platform_probe(struct platform_device *pdev) { return snd_soc_register_platform(&pdev->dev, &bf5xx_ac97_soc_platform); }