static int sst_platform_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime; struct sst_runtime_stream *stream; int ret_val = 0; pr_debug("sst_platform_open called\n"); runtime = substream->runtime; runtime->hw = sst_platform_pcm_hw; stream = kzalloc(sizeof(*stream), GFP_KERNEL); if (!stream) return -ENOMEM; spin_lock_init(&stream->status_lock); stream->stream_info.str_id = 0; sst_set_stream_status(stream, SST_PLATFORM_INIT); stream->stream_info.mad_substream = substream; /* allocate memory for SST API set */ stream->sstdrv_ops = kzalloc(sizeof(*stream->sstdrv_ops), GFP_KERNEL); if (!stream->sstdrv_ops) { pr_err("sst: mem allocation for ops fail\n"); kfree(stream); return -ENOMEM; } stream->sstdrv_ops->vendor_id = MSIC_VENDOR_ID; /* registering with SST driver to get access to SST APIs to use */ ret_val = register_sst_card(stream->sstdrv_ops); if (ret_val) { pr_err("sst: sst card registration failed\n"); return ret_val; } runtime->private_data = stream; return snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); }
static int sst_platform_compr_open(struct snd_compr_stream *cstream) { int ret_val = 0; struct snd_compr_runtime *runtime = cstream->runtime; struct sst_runtime_stream *stream; stream = kzalloc(sizeof(*stream), GFP_KERNEL); if (!stream) return -ENOMEM; spin_lock_init(&stream->status_lock); /* get the sst ops */ if (!sst || !try_module_get(sst->dev->driver->owner)) { pr_err("no device available to run\n"); ret_val = -ENODEV; goto out_ops; } stream->compr_ops = sst->compr_ops; stream->id = 0; sst_set_stream_status(stream, SST_PLATFORM_INIT); runtime->private_data = stream; return 0; out_ops: kfree(stream); return ret_val; }
static int sst_platform_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { int ret_val = 0, str_id; struct sst_runtime_stream *stream; int str_cmd, status, alsa_state; if (substream->pcm->internal) return 0; pr_debug("sst_platform_pcm_trigger called\n"); stream = substream->runtime->private_data; str_id = stream->stream_info.str_id; alsa_state = substream->runtime->status->state; switch (cmd) { case SNDRV_PCM_TRIGGER_START: pr_debug("Trigger Start\n"); str_cmd = SST_SND_START; status = SST_PLATFORM_RUNNING; stream->stream_info.mad_substream = substream; break; case SNDRV_PCM_TRIGGER_STOP: pr_debug("Trigger stop\n"); str_cmd = SST_SND_DROP; status = SST_PLATFORM_DROPPED; break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: pr_debug("Trigger pause\n"); str_cmd = SST_SND_PAUSE; status = SST_PLATFORM_PAUSED; break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: pr_debug("Trigger pause release\n"); str_cmd = SST_SND_RESUME; status = SST_PLATFORM_RUNNING; break; default: return -EINVAL; } ret_val = stream->ops->device_control(str_cmd, &str_id); if (!ret_val) sst_set_stream_status(stream, status); return ret_val; }
static int sst_media_open(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { int ret_val = 0; struct snd_pcm_runtime *runtime = substream->runtime; struct sst_runtime_stream *stream; stream = kzalloc(sizeof(*stream), GFP_KERNEL); if (!stream) return -ENOMEM; spin_lock_init(&stream->status_lock); /* get the sst ops */ mutex_lock(&sst_dsp_lock); if (!sst_dsp || !try_module_get(sst_dsp->dev->driver->owner)) { pr_err("no device available to run\n"); ret_val = -ENODEV; goto out_ops; } stream->ops = sst_dsp->ops; mutex_unlock(&sst_dsp_lock); stream->stream_info.str_id = 0; sst_set_stream_status(stream, SST_PLATFORM_UNINIT); stream->stream_info.mad_substream = substream; runtime->private_data = stream; if (strstr(dai->name, "Power-cpu-dai")) return power_up_sst(stream); /* Make sure, that the period size is always even */ snd_pcm_hw_constraint_step(substream->runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 2); pr_debug("buf_ptr %llu\n", stream->stream_info.buffer_ptr); return snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); out_ops: kfree(stream); mutex_unlock(&sst_dsp_lock); return ret_val; }
static int sst_platform_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { int ret_val = 0, str_id; struct sst_runtime_stream *stream; int status; struct snd_soc_pcm_runtime *rtd = substream->private_data; dev_dbg(rtd->dev, "sst_platform_pcm_trigger called\n"); if (substream->pcm->internal) return 0; stream = substream->runtime->private_data; str_id = stream->stream_info.str_id; switch (cmd) { case SNDRV_PCM_TRIGGER_START: dev_dbg(rtd->dev, "sst: Trigger Start\n"); status = SST_PLATFORM_RUNNING; stream->stream_info.arg = substream; ret_val = stream->ops->stream_start(sst->dev, str_id); break; case SNDRV_PCM_TRIGGER_STOP: dev_dbg(rtd->dev, "sst: in stop\n"); status = SST_PLATFORM_DROPPED; ret_val = stream->ops->stream_drop(sst->dev, str_id); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: dev_dbg(rtd->dev, "sst: in pause\n"); status = SST_PLATFORM_PAUSED; ret_val = stream->ops->stream_pause(sst->dev, str_id); break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: dev_dbg(rtd->dev, "sst: in pause release\n"); status = SST_PLATFORM_RUNNING; ret_val = stream->ops->stream_pause_release(sst->dev, str_id); break; default: return -EINVAL; } if (!ret_val) sst_set_stream_status(stream, status); return ret_val; }
static int sst_platform_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct sst_runtime_stream *stream; int ret_val; pr_debug("sst_platform_open called\n"); snd_soc_set_runtime_hwparams(substream, &sst_platform_pcm_hw); ret_val = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (ret_val < 0) return ret_val; stream = kzalloc(sizeof(*stream), GFP_KERNEL); if (!stream) return -ENOMEM; spin_lock_init(&stream->status_lock); /* get the sst ops */ mutex_lock(&sst_lock); if (!sst) { pr_err("no device available to run\n"); mutex_unlock(&sst_lock); kfree(stream); return -ENODEV; } if (!try_module_get(sst->dev->driver->owner)) { mutex_unlock(&sst_lock); kfree(stream); return -ENODEV; } stream->ops = sst->ops; mutex_unlock(&sst_lock); stream->stream_info.str_id = 0; sst_set_stream_status(stream, SST_PLATFORM_INIT); stream->stream_info.mad_substream = substream; /* allocate memory for SST API set */ runtime->private_data = stream; return 0; }
static int sst_platform_init_stream(struct snd_pcm_substream *substream) { struct sst_runtime_stream *stream = substream->runtime->private_data; int ret_val; pr_debug("setting buffer ptr param\n"); sst_set_stream_status(stream, SST_PLATFORM_INIT); stream->stream_info.period_elapsed = sst_period_elapsed; stream->stream_info.mad_substream = substream; stream->stream_info.buffer_ptr = 0; stream->stream_info.sfreq = substream->runtime->rate; ret_val = stream->ops->device_control( SST_SND_STREAM_INIT, &stream->stream_info); if (ret_val) pr_err("control_set ret error %d\n", ret_val); return ret_val; }
static int sst_platform_init_stream(struct snd_pcm_substream *substream) { struct sst_runtime_stream *stream = substream->runtime->private_data; struct snd_soc_pcm_runtime *rtd = substream->private_data; int ret_val; dev_dbg(rtd->dev, "setting buffer ptr param\n"); sst_set_stream_status(stream, SST_PLATFORM_INIT); stream->stream_info.period_elapsed = sst_period_elapsed; stream->stream_info.arg = substream; stream->stream_info.buffer_ptr = 0; stream->stream_info.sfreq = substream->runtime->rate; ret_val = stream->ops->stream_init(sst->dev, &stream->stream_info); if (ret_val) dev_err(rtd->dev, "control_set ret error %d\n", ret_val); return ret_val; }