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