| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Namarta Kohli | 760 | 25.55% | 1 | 0.90% |
| Liam Girdwood | 644 | 21.65% | 3 | 2.70% |
| Kuninori Morimoto | 633 | 21.28% | 55 | 49.55% |
| Charles Keepax | 300 | 10.08% | 13 | 11.71% |
| Vinod Koul | 192 | 6.45% | 3 | 2.70% |
| Mark Brown | 78 | 2.62% | 5 | 4.50% |
| Srinivas Kandagatla | 70 | 2.35% | 1 | 0.90% |
| Peter Ujfalusi | 40 | 1.34% | 1 | 0.90% |
| Jeeja KP | 36 | 1.21% | 1 | 0.90% |
| 강신형 | 32 | 1.08% | 1 | 0.90% |
| Lars-Peter Clausen | 24 | 0.81% | 2 | 1.80% |
| Benoît Cousson | 21 | 0.71% | 1 | 0.90% |
| Frank Mandarino | 15 | 0.50% | 1 | 0.90% |
| Cezary Rojewski | 14 | 0.47% | 1 | 0.90% |
| Amadeusz Sławiński | 13 | 0.44% | 1 | 0.90% |
| Daniel Baluta | 11 | 0.37% | 1 | 0.90% |
| Takashi Iwai | 10 | 0.34% | 1 | 0.90% |
| 이경택 | 10 | 0.34% | 1 | 0.90% |
| Qais Yousef | 10 | 0.34% | 1 | 0.90% |
| Jiasheng Jiang | 9 | 0.30% | 2 | 1.80% |
| Donglin Peng | 8 | 0.27% | 1 | 0.90% |
| Bard Liao | 7 | 0.24% | 1 | 0.90% |
| Atsushi Nemoto | 6 | 0.20% | 1 | 0.90% |
| Jie Yang | 6 | 0.20% | 1 | 0.90% |
| yixuanjiang | 5 | 0.17% | 1 | 0.90% |
| Qiao Zhou | 4 | 0.13% | 1 | 0.90% |
| Tejun Heo | 3 | 0.10% | 1 | 0.90% |
| Satish Babu Patakokila | 3 | 0.10% | 1 | 0.90% |
| Stephen Warren | 3 | 0.10% | 2 | 1.80% |
| Curtis Malainey | 2 | 0.07% | 1 | 0.90% |
| SF Markus Elfring | 2 | 0.07% | 1 | 0.90% |
| Richard Fitzgerald | 2 | 0.07% | 1 | 0.90% |
| Shengjiu Wang | 1 | 0.03% | 1 | 0.90% |
| Pierre-Louis Bossart | 1 | 0.03% | 1 | 0.90% |
| Total | 2975 | 111 |
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675
// SPDX-License-Identifier: GPL-2.0+ // // soc-compress.c -- ALSA SoC Compress // // Copyright (C) 2012 Intel Corp. // // Authors: Namarta Kohli <namartax.kohli@intel.com> // Ramesh Babu K V <ramesh.babu@linux.intel.com> // Vinod Koul <vinod.koul@linux.intel.com> #include <linux/kernel.h> #include <linux/init.h> #include <linux/delay.h> #include <linux/slab.h> #include <linux/workqueue.h> #include <sound/core.h> #include <sound/compress_params.h> #include <sound/compress_driver.h> #include <sound/soc.h> #include <sound/initval.h> #include <sound/soc-dpcm.h> #include <sound/soc-link.h> static int snd_soc_compr_components_open(struct snd_compr_stream *cstream) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_component *component; int ret = 0; int i; for_each_rtd_components(rtd, i, component) { ret = snd_soc_component_module_get_when_open(component, cstream); if (ret < 0) break; ret = snd_soc_component_compr_open(component, cstream); if (ret < 0) break; } return ret; } static void snd_soc_compr_components_free(struct snd_compr_stream *cstream, int rollback) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_component *component; int i; for_each_rtd_components(rtd, i, component) { snd_soc_component_compr_free(component, cstream, rollback); snd_soc_component_module_put_when_close(component, cstream, rollback); } } static int soc_compr_clean(struct snd_compr_stream *cstream, int rollback) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ snd_soc_dpcm_mutex_lock(rtd); if (!rollback) snd_soc_runtime_deactivate(rtd, stream); snd_soc_dai_digital_mute(codec_dai, 1, stream); if (!snd_soc_dai_active(cpu_dai)) cpu_dai->symmetric_rate = 0; if (!snd_soc_dai_active(codec_dai)) codec_dai->symmetric_rate = 0; snd_soc_link_compr_shutdown(cstream, rollback); snd_soc_compr_components_free(cstream, rollback); snd_soc_dai_compr_shutdown(cpu_dai, cstream, rollback); if (!rollback) snd_soc_dapm_stream_stop(rtd, stream); snd_soc_dpcm_mutex_unlock(rtd); snd_soc_pcm_component_pm_runtime_put(rtd, cstream, rollback); return 0; } static int soc_compr_free(struct snd_compr_stream *cstream) { return soc_compr_clean(cstream, 0); } static int soc_compr_open(struct snd_compr_stream *cstream) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ int ret; ret = snd_soc_pcm_component_pm_runtime_get(rtd, cstream); if (ret < 0) goto err_no_lock; snd_soc_dpcm_mutex_lock(rtd); ret = snd_soc_dai_compr_startup(cpu_dai, cstream); if (ret < 0) goto err; ret = snd_soc_compr_components_open(cstream); if (ret < 0) goto err; ret = snd_soc_link_compr_startup(cstream); if (ret < 0) goto err; snd_soc_runtime_activate(rtd, stream); err: snd_soc_dpcm_mutex_unlock(rtd); err_no_lock: if (ret < 0) soc_compr_clean(cstream, 1); return ret; } static int soc_compr_open_fe(struct snd_compr_stream *cstream) { struct snd_soc_pcm_runtime *fe = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(fe, 0); struct snd_soc_dpcm *dpcm; struct snd_soc_dapm_widget_list *list; int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ int ret; snd_soc_card_mutex_lock(fe->card); ret = dpcm_path_get(fe, stream, &list); if (ret < 0) goto be_err; snd_soc_dpcm_mutex_lock(fe); /* calculate valid and active FE <-> BE dpcms */ dpcm_process_paths(fe, stream, &list, 1); fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; ret = dpcm_be_dai_startup(fe, stream); if (ret < 0) { /* clean up all links */ for_each_dpcm_be(fe, stream, dpcm) dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; dpcm_be_disconnect(fe, stream); goto out; } ret = snd_soc_dai_compr_startup(cpu_dai, cstream); if (ret < 0) goto out; ret = snd_soc_compr_components_open(cstream); if (ret < 0) goto open_err; ret = snd_soc_link_compr_startup(cstream); if (ret < 0) goto machine_err; dpcm_clear_pending_state(fe, stream); dpcm_path_put(&list); fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN; fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; snd_soc_runtime_activate(fe, stream); snd_soc_dpcm_mutex_unlock(fe); snd_soc_card_mutex_unlock(fe->card); return 0; machine_err: snd_soc_compr_components_free(cstream, 1); open_err: snd_soc_dai_compr_shutdown(cpu_dai, cstream, 1); out: dpcm_path_put(&list); snd_soc_dpcm_mutex_unlock(fe); be_err: fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; snd_soc_card_mutex_unlock(fe->card); return ret; } static int soc_compr_free_fe(struct snd_compr_stream *cstream) { struct snd_soc_pcm_runtime *fe = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(fe, 0); struct snd_soc_dpcm *dpcm; int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ snd_soc_card_mutex_lock(fe->card); snd_soc_dpcm_mutex_lock(fe); snd_soc_runtime_deactivate(fe, stream); fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; dpcm_be_dai_hw_free(fe, stream); dpcm_be_dai_shutdown(fe, stream); /* mark FE's links ready to prune */ for_each_dpcm_be(fe, stream, dpcm) dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP); fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE; fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; dpcm_be_disconnect(fe, stream); snd_soc_dpcm_mutex_unlock(fe); snd_soc_link_compr_shutdown(cstream, 0); snd_soc_compr_components_free(cstream, 0); snd_soc_dai_compr_shutdown(cpu_dai, cstream, 0); snd_soc_card_mutex_unlock(fe->card); return 0; } static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ int ret; snd_soc_dpcm_mutex_lock(rtd); ret = snd_soc_component_compr_trigger(cstream, cmd); if (ret < 0) goto out; ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd); if (ret < 0) goto out; switch (cmd) { case SNDRV_PCM_TRIGGER_START: snd_soc_dai_digital_mute(codec_dai, 0, stream); break; case SNDRV_PCM_TRIGGER_STOP: snd_soc_dai_digital_mute(codec_dai, 1, stream); break; } out: snd_soc_dpcm_mutex_unlock(rtd); return ret; } static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd) { struct snd_soc_pcm_runtime *fe = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(fe, 0); int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ int ret; if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN || cmd == SND_COMPR_TRIGGER_DRAIN) return snd_soc_component_compr_trigger(cstream, cmd); snd_soc_card_mutex_lock(fe->card); ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd); if (ret < 0) goto out; ret = snd_soc_component_compr_trigger(cstream, cmd); if (ret < 0) goto out; fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; ret = dpcm_be_dai_trigger(fe, stream, cmd); switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START; break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP; break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED; break; } out: fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; snd_soc_card_mutex_unlock(fe->card); return ret; } static int soc_compr_set_params(struct snd_compr_stream *cstream, struct snd_compr_params *params) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ int ret; snd_soc_dpcm_mutex_lock(rtd); /* * First we call set_params for the CPU DAI, then the component * driver this should configure the SoC side. If the machine has * compressed ops then we call that as well. The expectation is * that these callbacks will configure everything for this compress * path, like configuring a PCM port for a CODEC. */ ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params); if (ret < 0) goto err; ret = snd_soc_component_compr_set_params(cstream, params); if (ret < 0) goto err; ret = snd_soc_link_compr_set_params(cstream); if (ret < 0) goto err; snd_soc_dapm_stream_event(rtd, stream, SND_SOC_DAPM_STREAM_START); /* cancel any delayed stream shutdown that is pending */ rtd->pop_wait = 0; snd_soc_dpcm_mutex_unlock(rtd); cancel_delayed_work_sync(&rtd->delayed_work); return 0; err: snd_soc_dpcm_mutex_unlock(rtd); return ret; } static int soc_compr_set_params_fe(struct snd_compr_stream *cstream, struct snd_compr_params *params) { struct snd_soc_pcm_runtime *fe = cstream->private_data; struct snd_pcm_substream *fe_substream = fe->pcm->streams[cstream->direction].substream; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(fe, 0); int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ int ret; snd_soc_card_mutex_lock(fe->card); /* * Create an empty hw_params for the BE as the machine driver must * fix this up to match DSP decoder and ASRC configuration. * I.e. machine driver fixup for compressed BE is mandatory. */ memset(&fe->dpcm[fe_substream->stream].hw_params, 0, sizeof(struct snd_pcm_hw_params)); fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; snd_soc_dpcm_mutex_lock(fe); ret = dpcm_be_dai_hw_params(fe, stream); snd_soc_dpcm_mutex_unlock(fe); if (ret < 0) goto out; snd_soc_dpcm_mutex_lock(fe); ret = dpcm_be_dai_prepare(fe, stream); snd_soc_dpcm_mutex_unlock(fe); if (ret < 0) goto out; ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params); if (ret < 0) goto out; ret = snd_soc_component_compr_set_params(cstream, params); if (ret < 0) goto out; ret = snd_soc_link_compr_set_params(cstream); if (ret < 0) goto out; snd_soc_dpcm_mutex_lock(fe); dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START); snd_soc_dpcm_mutex_unlock(fe); fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE; out: fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; snd_soc_card_mutex_unlock(fe->card); return ret; } static int soc_compr_get_params(struct snd_compr_stream *cstream, struct snd_codec *params) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int ret = 0; snd_soc_dpcm_mutex_lock(rtd); ret = snd_soc_dai_compr_get_params(cpu_dai, cstream, params); if (ret < 0) goto err; ret = snd_soc_component_compr_get_params(cstream, params); err: snd_soc_dpcm_mutex_unlock(rtd); return ret; } static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int ret; snd_soc_dpcm_mutex_lock(rtd); ret = snd_soc_dai_compr_ack(cpu_dai, cstream, bytes); if (ret < 0) goto err; ret = snd_soc_component_compr_ack(cstream, bytes); err: snd_soc_dpcm_mutex_unlock(rtd); return ret; } static int soc_compr_pointer(struct snd_compr_stream *cstream, struct snd_compr_tstamp *tstamp) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; int ret; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); snd_soc_dpcm_mutex_lock(rtd); ret = snd_soc_dai_compr_pointer(cpu_dai, cstream, tstamp); if (ret < 0) goto out; ret = snd_soc_component_compr_pointer(cstream, tstamp); out: snd_soc_dpcm_mutex_unlock(rtd); return ret; } static int soc_compr_set_metadata(struct snd_compr_stream *cstream, struct snd_compr_metadata *metadata) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int ret; ret = snd_soc_dai_compr_set_metadata(cpu_dai, cstream, metadata); if (ret < 0) return ret; return snd_soc_component_compr_set_metadata(cstream, metadata); } static int soc_compr_get_metadata(struct snd_compr_stream *cstream, struct snd_compr_metadata *metadata) { struct snd_soc_pcm_runtime *rtd = cstream->private_data; struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); int ret; ret = snd_soc_dai_compr_get_metadata(cpu_dai, cstream, metadata); if (ret < 0) return ret; return snd_soc_component_compr_get_metadata(cstream, metadata); } /* ASoC Compress operations */ static struct snd_compr_ops soc_compr_ops = { .open = soc_compr_open, .free = soc_compr_free, .set_params = soc_compr_set_params, .set_metadata = soc_compr_set_metadata, .get_metadata = soc_compr_get_metadata, .get_params = soc_compr_get_params, .trigger = soc_compr_trigger, .pointer = soc_compr_pointer, .ack = soc_compr_ack, .get_caps = snd_soc_component_compr_get_caps, .get_codec_caps = snd_soc_component_compr_get_codec_caps, }; /* ASoC Dynamic Compress operations */ static struct snd_compr_ops soc_compr_dyn_ops = { .open = soc_compr_open_fe, .free = soc_compr_free_fe, .set_params = soc_compr_set_params_fe, .get_params = soc_compr_get_params, .set_metadata = soc_compr_set_metadata, .get_metadata = soc_compr_get_metadata, .trigger = soc_compr_trigger_fe, .pointer = soc_compr_pointer, .ack = soc_compr_ack, .get_caps = snd_soc_component_compr_get_caps, .get_codec_caps = snd_soc_component_compr_get_codec_caps, }; /** * snd_soc_new_compress - create a new compress. * * @rtd: The runtime for which we will create compress * * Return: 0 for success, else error. */ int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_component *component; struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); struct snd_compr *compr; struct snd_pcm *be_pcm; char new_name[64]; int ret = 0, direction = 0; int playback = 0, capture = 0; int i; /* * make sure these are same value, * and then use these as equally */ BUILD_BUG_ON((int)SNDRV_PCM_STREAM_PLAYBACK != (int)SND_COMPRESS_PLAYBACK); BUILD_BUG_ON((int)SNDRV_PCM_STREAM_CAPTURE != (int)SND_COMPRESS_CAPTURE); if (rtd->dai_link->num_cpus > 1 || rtd->dai_link->num_codecs > 1) { dev_err(rtd->card->dev, "Compress ASoC: Multi CPU/Codec not supported\n"); return -EINVAL; } if (!codec_dai) { dev_err(rtd->card->dev, "Missing codec\n"); return -EINVAL; } /* check client and interface hw capabilities */ if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) && snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_PLAYBACK)) playback = 1; if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) && snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_CAPTURE)) capture = 1; /* * Compress devices are unidirectional so only one of the directions * should be set, check for that (xor) */ if (playback + capture != 1) { dev_err(rtd->card->dev, "Compress ASoC: Invalid direction for P %d, C %d\n", playback, capture); return -EINVAL; } if (playback) direction = SND_COMPRESS_PLAYBACK; else direction = SND_COMPRESS_CAPTURE; compr = devm_kzalloc(rtd->card->dev, sizeof(*compr), GFP_KERNEL); if (!compr) return -ENOMEM; compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), GFP_KERNEL); if (!compr->ops) return -ENOMEM; if (rtd->dai_link->dynamic) { int playback = 1; int capture = 1; if (rtd->dai_link->capture_only) playback = 0; if (rtd->dai_link->playback_only) capture = 0; snprintf(new_name, sizeof(new_name), "(%s)", rtd->dai_link->stream_name); ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, rtd->id, playback, capture, &be_pcm); if (ret < 0) { dev_err(rtd->card->dev, "Compress ASoC: can't create compressed for %s: %d\n", rtd->dai_link->name, ret); return ret; } /* inherit atomicity from DAI link */ be_pcm->nonatomic = rtd->dai_link->nonatomic; rtd->pcm = be_pcm; rtd->fe_compr = 1; if (playback) be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; if (capture) be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops)); } else { snprintf(new_name, sizeof(new_name), "%s %s-%d", rtd->dai_link->stream_name, codec_dai->name, rtd->id); memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); } for_each_rtd_components(rtd, i, component) { if (!component->driver->compress_ops || !component->driver->compress_ops->copy) continue; compr->ops->copy = snd_soc_component_compr_copy; break; } ret = snd_compress_new(rtd->card->snd_card, rtd->id, direction, new_name, compr); if (ret < 0) { component = snd_soc_rtd_to_codec(rtd, 0)->component; dev_err(component->dev, "Compress ASoC: can't create compress for codec %s: %d\n", component->name, ret); return ret; } /* DAPM dai link stream work */ rtd->close_delayed_work_func = snd_soc_close_delayed_work; rtd->compr = compr; compr->private_data = rtd; dev_dbg(rtd->card->dev, "Compress ASoC: %s <-> %s mapping ok\n", codec_dai->name, cpu_dai->name); return 0; } EXPORT_SYMBOL_GPL(snd_soc_new_compress);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1