static int msm_compr_probe(struct snd_soc_platform *platform) { struct msm_compr_pdata *pdata; int i; pr_debug("%s\n", __func__); pdata = (struct msm_compr_pdata *) kzalloc(sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; snd_soc_platform_set_drvdata(platform, pdata); atomic_set(&pdata->audio_ocmem_req, 0); for (i = 0; i < MSM_FRONTEND_DAI_MAX; i++) { pdata->volume[i][0] = COMPRESSED_LR_VOL_MAX_STEPS; pdata->volume[i][1] = COMPRESSED_LR_VOL_MAX_STEPS; pdata->audio_effects[i] = NULL; pdata->cstream[i] = NULL; } /* * use_dsp_gapless_mode part of platform data(pdata) is updated from HAL * through a mixer control before compress driver is opened. The mixer * control is used to decide if dsp gapless mode needs to be enabled. * Gapless is disabled by default. */ pdata->use_dsp_gapless_mode = false; return 0; }
static int ath79_pcm_close(struct snd_pcm_substream *ss) { struct snd_soc_pcm_runtime *runtime = ss->private_data; struct snd_soc_platform *platform = runtime->platform; struct ath79_pcm_pltfm_priv *prdata = snd_soc_platform_get_drvdata(platform); struct ath79_pcm_rt_priv *rtpriv; if (!prdata) return 0; if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) { prdata->playback = NULL; } else { prdata->capture = NULL; } if (!prdata->playback && !prdata->capture) { free_irq(ATH79_MISC_IRQ(7), prdata); kfree(prdata); snd_soc_platform_set_drvdata(platform, NULL); } rtpriv = ss->runtime->private_data; kfree(rtpriv); return 0; }
/* * msm_asoc_cpe_lsm_probe: ASoC framework for lsm platform driver * @platform: platform registered with ASoC core * * Allocate the private data for this platform and obtain the ops for * lsm and afe modules from underlying driver. Also find the codec * for this platform as specified by machine driver for ASoC framework. */ static int msm_asoc_cpe_lsm_probe(struct snd_soc_platform *platform) { struct snd_soc_card *card; struct snd_soc_pcm_runtime *rtd; struct snd_soc_codec *codec; struct cpe_priv *cpe_priv; bool found_runtime = false; int i; if (!platform || !platform->card) { pr_err("%s: Invalid platform or card\n", __func__); return -EINVAL; } card = platform->card; /* Match platform to codec */ for (i = 0; i < card->num_links; i++) { rtd = &card->rtd[i]; if (!rtd->platform) continue; if (!strcmp(rtd->platform->name, platform->name)) { found_runtime = true; break; } } if (!found_runtime) { dev_err(platform->dev, "%s: Failed to find runtime for platform\n", __func__); return -EINVAL; } codec = rtd->codec; cpe_priv = kzalloc(sizeof(struct cpe_priv), GFP_KERNEL); if (!cpe_priv) { dev_err(platform->dev, "%s: no memory for priv data, size = %zd\n", __func__, sizeof(struct cpe_priv)); return -ENOMEM; } cpe_priv->codec = codec; wcd_cpe_get_lsm_ops(&cpe_priv->lsm_ops); wcd_cpe_get_afe_ops(&cpe_priv->afe_ops); snd_soc_platform_set_drvdata(platform, cpe_priv); return 0; }
static int ath79_pcm_open(struct snd_pcm_substream *ss) { struct snd_soc_pcm_runtime *runtime = ss->private_data; struct snd_soc_platform *platform = runtime->platform; struct ath79_pcm_pltfm_priv *prdata = snd_soc_platform_get_drvdata(platform); struct ath79_pcm_rt_priv *rtpriv; int err; if (prdata == NULL) { prdata = kzalloc(sizeof(struct ath79_pcm_pltfm_priv), GFP_KERNEL); if (prdata == NULL) return -ENOMEM; err = request_irq(ATH79_MISC_IRQ(7), ath79_pcm_interrupt, 0, "ath79-pcm", prdata); if (err) { kfree(prdata); return -EBUSY; } snd_soc_platform_set_drvdata(platform, prdata); } if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) { prdata->playback = ss; } else { prdata->capture = ss; } /* Allocate/Initialize the buffer linked list head */ rtpriv = kmalloc(sizeof(*rtpriv), GFP_KERNEL); if (!rtpriv) { return -ENOMEM; } snd_printd("%s: 0x%xB allocated at 0x%08x\n", __FUNCTION__, sizeof(*rtpriv), (u32) rtpriv); ss->runtime->private_data = rtpriv; rtpriv->last_played = NULL; INIT_LIST_HEAD(&rtpriv->dma_head); if(ss->stream == SNDRV_PCM_STREAM_PLAYBACK) rtpriv->direction = SNDRV_PCM_STREAM_PLAYBACK; else rtpriv->direction = SNDRV_PCM_STREAM_CAPTURE; snd_soc_set_runtime_hwparams(ss, &ath79_pcm_hardware); return 0; }
static int hsw_pcm_probe(struct snd_soc_platform *platform) { struct sst_pdata *pdata = dev_get_platdata(platform->dev); struct hsw_priv_data *priv_data; int i; if (!pdata) return -ENODEV; priv_data = devm_kzalloc(platform->dev, sizeof(*priv_data), GFP_KERNEL); priv_data->hsw = pdata->dsp; snd_soc_platform_set_drvdata(platform, priv_data); /* allocate DSP buffer page tables */ for (i = 0; i < ARRAY_SIZE(hsw_dais); i++) { mutex_init(&priv_data->pcm[i].mutex); /* playback */ if (hsw_dais[i].playback.channels_min) { priv_data->pcm_pg[i][0] = kzalloc(PAGE_SIZE, GFP_DMA); if (priv_data->pcm_pg[i][0] == NULL) goto err; } /* capture */ if (hsw_dais[i].capture.channels_min) { priv_data->pcm_pg[i][1] = kzalloc(PAGE_SIZE, GFP_DMA); if (priv_data->pcm_pg[i][1] == NULL) goto err; } } return 0; err: for (;i >= 0; i--) { if (hsw_dais[i].playback.channels_min) kfree(priv_data->pcm_pg[i][0]); if (hsw_dais[i].capture.channels_min) kfree(priv_data->pcm_pg[i][1]); } return -ENOMEM; }
static int sst_byt_pcm_probe(struct snd_soc_platform *platform) { struct sst_pdata *plat_data = dev_get_platdata(platform->dev); struct sst_byt_priv_data *priv_data; int i; if (!plat_data) return -ENODEV; priv_data = devm_kzalloc(platform->dev, sizeof(*priv_data), GFP_KERNEL); priv_data->byt = plat_data->dsp; snd_soc_platform_set_drvdata(platform, priv_data); for (i = 0; i < ARRAY_SIZE(byt_dais); i++) mutex_init(&priv_data->pcm[i].mutex); return 0; }
static int sst_byt_pcm_probe(struct snd_soc_platform *platform) { struct sst_pdata *plat_data = dev_get_platdata(platform->dev); struct sst_byt_priv_data *priv_data; int i; if (!plat_data) return -ENODEV; priv_data = devm_kzalloc(platform->dev, sizeof(*priv_data), GFP_KERNEL); priv_data->byt = plat_data->dsp; snd_soc_platform_set_drvdata(platform, priv_data); for (i = 0; i < BYT_PCM_COUNT; i++) { mutex_init(&priv_data->pcm[i].mutex); INIT_WORK(&priv_data->pcm[i].work, sst_byt_pcm_work); } return 0; }
static int msm_compr_probe(struct snd_soc_platform *platform) { struct msm_compr_pdata *pdata; int i; pr_debug("%s\n", __func__); pdata = (struct msm_compr_pdata *) kzalloc(sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; snd_soc_platform_set_drvdata(platform, pdata); atomic_set(&pdata->audio_ocmem_req, 0); for (i = 0; i < MSM_FRONTEND_DAI_MAX; i++) { pdata->volume[i][0] = COMPRESSED_LR_VOL_MAX_STEPS; pdata->volume[i][1] = COMPRESSED_LR_VOL_MAX_STEPS; pdata->cstream[i] = NULL; } return 0; }