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);
}
