1 // SPDX-License-Identifier: GPL-2.0
3 * APBridge ALSA SoC dummy codec driver
4 * Copyright 2016 Google Inc.
5 * Copyright 2016 Linaro Ltd.
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/pm_runtime.h>
10 #include <sound/soc.h>
11 #include <sound/pcm_params.h>
12 #include <uapi/linux/input.h>
14 #include "audio_codec.h"
15 #include "audio_apbridgea.h"
16 #include "audio_manager.h"
18 static struct gbaudio_codec_info *gbcodec;
20 static struct gbaudio_data_connection *
21 find_data(struct gbaudio_module_info *module, int id)
23 struct gbaudio_data_connection *data;
25 list_for_each_entry(data, &module->data_list, list) {
32 static struct gbaudio_stream_params *
33 find_dai_stream_params(struct gbaudio_codec_info *codec, int id, int stream)
35 struct gbaudio_codec_dai *dai;
37 list_for_each_entry(dai, &codec->dai_list, list) {
39 return &dai->params[stream];
44 static int gbaudio_module_enable_tx(struct gbaudio_codec_info *codec,
45 struct gbaudio_module_info *module, int id)
47 int module_state, ret = 0;
48 u16 data_cport, i2s_port, cportid;
49 u8 sig_bits, channels;
51 struct gbaudio_data_connection *data;
52 struct gbaudio_stream_params *params;
55 data = find_data(module, id);
57 dev_err(module->dev, "%d:DATA connection missing\n", id);
60 module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
62 params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_PLAYBACK);
64 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
69 if (module_state < GBAUDIO_CODEC_STARTUP) {
70 i2s_port = 0; /* fixed for now */
71 cportid = data->connection->hd_cport_id;
72 ret = gb_audio_apbridgea_register_cport(data->connection,
74 AUDIO_APBRIDGEA_DIRECTION_TX);
76 dev_err_ratelimited(module->dev,
77 "reg_cport failed:%d\n", ret);
80 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
81 GBAUDIO_CODEC_STARTUP;
82 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
86 if (module_state < GBAUDIO_CODEC_HWPARAMS) {
87 format = params->format;
88 channels = params->channels;
90 sig_bits = params->sig_bits;
91 data_cport = data->connection->intf_cport_id;
92 ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
93 format, rate, channels, sig_bits);
95 dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
99 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
100 GBAUDIO_CODEC_HWPARAMS;
101 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
105 if (module_state < GBAUDIO_CODEC_PREPARE) {
106 data_cport = data->connection->intf_cport_id;
107 ret = gb_audio_gb_set_tx_data_size(module->mgmt_connection,
110 dev_err_ratelimited(module->dev,
111 "set_tx_data_size failed:%d\n",
115 ret = gb_audio_gb_activate_tx(module->mgmt_connection,
118 dev_err_ratelimited(module->dev,
119 "activate_tx failed:%d\n", ret);
122 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
123 GBAUDIO_CODEC_PREPARE;
124 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
130 static int gbaudio_module_disable_tx(struct gbaudio_module_info *module, int id)
133 u16 data_cport, cportid, i2s_port;
135 struct gbaudio_data_connection *data;
138 data = find_data(module, id);
140 dev_err(module->dev, "%d:DATA connection missing\n", id);
143 module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
145 if (module_state > GBAUDIO_CODEC_HWPARAMS) {
146 data_cport = data->connection->intf_cport_id;
147 ret = gb_audio_gb_deactivate_tx(module->mgmt_connection,
150 dev_err_ratelimited(module->dev,
151 "deactivate_tx failed:%d\n", ret);
154 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
155 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
156 GBAUDIO_CODEC_HWPARAMS;
159 if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
160 i2s_port = 0; /* fixed for now */
161 cportid = data->connection->hd_cport_id;
162 ret = gb_audio_apbridgea_unregister_cport(data->connection,
164 AUDIO_APBRIDGEA_DIRECTION_TX);
166 dev_err_ratelimited(module->dev,
167 "unregister_cport failed:%d\n",
171 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
172 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
173 GBAUDIO_CODEC_SHUTDOWN;
179 static int gbaudio_module_enable_rx(struct gbaudio_codec_info *codec,
180 struct gbaudio_module_info *module, int id)
182 int module_state, ret = 0;
183 u16 data_cport, i2s_port, cportid;
184 u8 sig_bits, channels;
186 struct gbaudio_data_connection *data;
187 struct gbaudio_stream_params *params;
190 data = find_data(module, id);
192 dev_err(module->dev, "%d:DATA connection missing\n", id);
195 module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
197 params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_CAPTURE);
199 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
204 if (module_state < GBAUDIO_CODEC_STARTUP) {
205 i2s_port = 0; /* fixed for now */
206 cportid = data->connection->hd_cport_id;
207 ret = gb_audio_apbridgea_register_cport(data->connection,
209 AUDIO_APBRIDGEA_DIRECTION_RX);
211 dev_err_ratelimited(module->dev,
212 "reg_cport failed:%d\n", ret);
215 data->state[SNDRV_PCM_STREAM_CAPTURE] =
216 GBAUDIO_CODEC_STARTUP;
217 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
221 if (module_state < GBAUDIO_CODEC_HWPARAMS) {
222 format = params->format;
223 channels = params->channels;
225 sig_bits = params->sig_bits;
226 data_cport = data->connection->intf_cport_id;
227 ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
228 format, rate, channels, sig_bits);
230 dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
234 data->state[SNDRV_PCM_STREAM_CAPTURE] =
235 GBAUDIO_CODEC_HWPARAMS;
236 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
240 if (module_state < GBAUDIO_CODEC_PREPARE) {
241 data_cport = data->connection->intf_cport_id;
242 ret = gb_audio_gb_set_rx_data_size(module->mgmt_connection,
245 dev_err_ratelimited(module->dev,
246 "set_rx_data_size failed:%d\n",
250 ret = gb_audio_gb_activate_rx(module->mgmt_connection,
253 dev_err_ratelimited(module->dev,
254 "activate_rx failed:%d\n", ret);
257 data->state[SNDRV_PCM_STREAM_CAPTURE] =
258 GBAUDIO_CODEC_PREPARE;
259 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
265 static int gbaudio_module_disable_rx(struct gbaudio_module_info *module, int id)
268 u16 data_cport, cportid, i2s_port;
270 struct gbaudio_data_connection *data;
273 data = find_data(module, id);
275 dev_err(module->dev, "%d:DATA connection missing\n", id);
278 module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
280 if (module_state > GBAUDIO_CODEC_HWPARAMS) {
281 data_cport = data->connection->intf_cport_id;
282 ret = gb_audio_gb_deactivate_rx(module->mgmt_connection,
285 dev_err_ratelimited(module->dev,
286 "deactivate_rx failed:%d\n", ret);
289 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
290 data->state[SNDRV_PCM_STREAM_CAPTURE] =
291 GBAUDIO_CODEC_HWPARAMS;
294 if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
295 i2s_port = 0; /* fixed for now */
296 cportid = data->connection->hd_cport_id;
297 ret = gb_audio_apbridgea_unregister_cport(data->connection,
299 AUDIO_APBRIDGEA_DIRECTION_RX);
301 dev_err_ratelimited(module->dev,
302 "unregister_cport failed:%d\n",
306 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
307 data->state[SNDRV_PCM_STREAM_CAPTURE] =
308 GBAUDIO_CODEC_SHUTDOWN;
314 int gbaudio_module_update(struct gbaudio_codec_info *codec,
315 struct snd_soc_dapm_widget *w,
316 struct gbaudio_module_info *module, int enable)
319 char intf_name[NAME_SIZE], dir[NAME_SIZE];
321 dev_dbg(module->dev, "%s:Module update %s sequence\n", w->name,
322 enable ? "Enable" : "Disable");
324 if ((w->id != snd_soc_dapm_aif_in) && (w->id != snd_soc_dapm_aif_out)) {
325 dev_dbg(codec->dev, "No action required for %s\n", w->name);
329 /* parse dai_id from AIF widget's stream_name */
330 ret = sscanf(w->sname, "%s %d %s", intf_name, &dai_id, dir);
332 dev_err(codec->dev, "Error while parsing dai_id for %s\n",
337 mutex_lock(&codec->lock);
338 if (w->id == snd_soc_dapm_aif_in) {
340 ret = gbaudio_module_enable_tx(codec, module, dai_id);
342 ret = gbaudio_module_disable_tx(module, dai_id);
343 } else if (w->id == snd_soc_dapm_aif_out) {
345 ret = gbaudio_module_enable_rx(codec, module, dai_id);
347 ret = gbaudio_module_disable_rx(module, dai_id);
350 mutex_unlock(&codec->lock);
354 EXPORT_SYMBOL(gbaudio_module_update);
359 static int gbcodec_startup(struct snd_pcm_substream *substream,
360 struct snd_soc_dai *dai)
362 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
363 struct gbaudio_stream_params *params;
365 mutex_lock(&codec->lock);
367 if (list_empty(&codec->module_list)) {
368 dev_err(codec->dev, "No codec module available\n");
369 mutex_unlock(&codec->lock);
373 params = find_dai_stream_params(codec, dai->id, substream->stream);
375 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
376 mutex_unlock(&codec->lock);
379 params->state = GBAUDIO_CODEC_STARTUP;
380 mutex_unlock(&codec->lock);
381 /* to prevent suspend in case of active audio */
382 pm_stay_awake(dai->dev);
387 static void gbcodec_shutdown(struct snd_pcm_substream *substream,
388 struct snd_soc_dai *dai)
390 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
391 struct gbaudio_stream_params *params;
393 mutex_lock(&codec->lock);
395 if (list_empty(&codec->module_list))
396 dev_info(codec->dev, "No codec module available during shutdown\n");
398 params = find_dai_stream_params(codec, dai->id, substream->stream);
400 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
401 mutex_unlock(&codec->lock);
404 params->state = GBAUDIO_CODEC_SHUTDOWN;
405 mutex_unlock(&codec->lock);
409 static int gbcodec_hw_params(struct snd_pcm_substream *substream,
410 struct snd_pcm_hw_params *hwparams,
411 struct snd_soc_dai *dai)
414 u8 sig_bits, channels;
416 struct gbaudio_module_info *module;
417 struct gbaudio_data_connection *data;
418 struct gb_bundle *bundle;
419 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
420 struct gbaudio_stream_params *params;
422 mutex_lock(&codec->lock);
424 if (list_empty(&codec->module_list)) {
425 dev_err(codec->dev, "No codec module available\n");
426 mutex_unlock(&codec->lock);
431 * assuming, currently only 48000 Hz, 16BIT_LE, stereo
432 * is supported, validate params before configuring codec
434 if (params_channels(hwparams) != 2) {
435 dev_err(dai->dev, "Invalid channel count:%d\n",
436 params_channels(hwparams));
437 mutex_unlock(&codec->lock);
440 channels = params_channels(hwparams);
442 if (params_rate(hwparams) != 48000) {
443 dev_err(dai->dev, "Invalid sampling rate:%d\n",
444 params_rate(hwparams));
445 mutex_unlock(&codec->lock);
448 rate = GB_AUDIO_PCM_RATE_48000;
450 if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) {
451 dev_err(dai->dev, "Invalid format:%d\n",
452 params_format(hwparams));
453 mutex_unlock(&codec->lock);
456 format = GB_AUDIO_PCM_FMT_S16_LE;
458 /* find the data connection */
459 list_for_each_entry(module, &codec->module_list, list) {
460 data = find_data(module, dai->id);
466 dev_err(dai->dev, "DATA connection missing\n");
467 mutex_unlock(&codec->lock);
471 params = find_dai_stream_params(codec, dai->id, substream->stream);
473 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
474 mutex_unlock(&codec->lock);
478 bundle = to_gb_bundle(module->dev);
479 ret = gb_pm_runtime_get_sync(bundle);
481 mutex_unlock(&codec->lock);
485 ret = gb_audio_apbridgea_set_config(data->connection, 0,
486 AUDIO_APBRIDGEA_PCM_FMT_16,
487 AUDIO_APBRIDGEA_PCM_RATE_48000,
490 dev_err_ratelimited(dai->dev, "%d: Error during set_config\n",
492 gb_pm_runtime_put_noidle(bundle);
493 mutex_unlock(&codec->lock);
497 gb_pm_runtime_put_noidle(bundle);
499 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
500 sig_bits = dai->driver->playback.sig_bits;
502 sig_bits = dai->driver->capture.sig_bits;
504 params->state = GBAUDIO_CODEC_HWPARAMS;
505 params->format = format;
507 params->channels = channels;
508 params->sig_bits = sig_bits;
510 mutex_unlock(&codec->lock);
514 static int gbcodec_prepare(struct snd_pcm_substream *substream,
515 struct snd_soc_dai *dai)
518 struct gbaudio_module_info *module;
519 struct gbaudio_data_connection *data;
520 struct gb_bundle *bundle;
521 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
522 struct gbaudio_stream_params *params;
524 mutex_lock(&codec->lock);
526 if (list_empty(&codec->module_list)) {
527 dev_err(codec->dev, "No codec module available\n");
528 mutex_unlock(&codec->lock);
532 list_for_each_entry(module, &codec->module_list, list) {
534 data = find_data(module, dai->id);
539 dev_err(dai->dev, "DATA connection missing\n");
540 mutex_unlock(&codec->lock);
544 params = find_dai_stream_params(codec, dai->id, substream->stream);
546 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
547 mutex_unlock(&codec->lock);
551 bundle = to_gb_bundle(module->dev);
552 ret = gb_pm_runtime_get_sync(bundle);
554 mutex_unlock(&codec->lock);
558 switch (substream->stream) {
559 case SNDRV_PCM_STREAM_PLAYBACK:
560 ret = gb_audio_apbridgea_set_tx_data_size(data->connection, 0,
563 case SNDRV_PCM_STREAM_CAPTURE:
564 ret = gb_audio_apbridgea_set_rx_data_size(data->connection, 0,
569 gb_pm_runtime_put_noidle(bundle);
570 mutex_unlock(&codec->lock);
571 dev_err_ratelimited(dai->dev, "set_data_size failed:%d\n",
576 gb_pm_runtime_put_noidle(bundle);
578 params->state = GBAUDIO_CODEC_PREPARE;
579 mutex_unlock(&codec->lock);
583 static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
586 struct gbaudio_data_connection *data;
587 struct gbaudio_module_info *module;
588 struct gb_bundle *bundle;
589 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
590 struct gbaudio_stream_params *params;
592 dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
593 stream ? "CAPTURE" : "PLAYBACK");
595 mutex_lock(&codec->lock);
597 params = find_dai_stream_params(codec, dai->id, stream);
599 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
600 mutex_unlock(&codec->lock);
604 if (list_empty(&codec->module_list)) {
605 dev_err(codec->dev, "No codec module available\n");
607 params->state = GBAUDIO_CODEC_STOP;
612 mutex_unlock(&codec->lock);
616 list_for_each_entry(module, &codec->module_list, list) {
618 data = find_data(module, dai->id);
623 dev_err(dai->dev, "%s DATA connection missing\n",
625 mutex_unlock(&codec->lock);
629 bundle = to_gb_bundle(module->dev);
630 ret = gb_pm_runtime_get_sync(bundle);
632 mutex_unlock(&codec->lock);
636 if (!mute && !stream) {/* start playback */
637 ret = gb_audio_apbridgea_prepare_tx(data->connection,
640 ret = gb_audio_apbridgea_start_tx(data->connection,
642 params->state = GBAUDIO_CODEC_START;
643 } else if (!mute && stream) {/* start capture */
644 ret = gb_audio_apbridgea_prepare_rx(data->connection,
647 ret = gb_audio_apbridgea_start_rx(data->connection,
649 params->state = GBAUDIO_CODEC_START;
650 } else if (mute && !stream) {/* stop playback */
651 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
653 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
655 params->state = GBAUDIO_CODEC_STOP;
656 } else if (mute && stream) {/* stop capture */
657 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
659 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
661 params->state = GBAUDIO_CODEC_STOP;
667 dev_err_ratelimited(dai->dev,
668 "%s:Error during %s %s stream:%d\n",
669 module->name, mute ? "Mute" : "Unmute",
670 stream ? "Capture" : "Playback", ret);
672 gb_pm_runtime_put_noidle(bundle);
673 mutex_unlock(&codec->lock);
677 static const struct snd_soc_dai_ops gbcodec_dai_ops = {
678 .startup = gbcodec_startup,
679 .shutdown = gbcodec_shutdown,
680 .hw_params = gbcodec_hw_params,
681 .prepare = gbcodec_prepare,
682 .mute_stream = gbcodec_mute_stream,
685 static struct snd_soc_dai_driver gbaudio_dai[] = {
690 .stream_name = "I2S 0 Playback",
691 .rates = SNDRV_PCM_RATE_48000,
692 .formats = SNDRV_PCM_FORMAT_S16_LE,
700 .stream_name = "I2S 0 Capture",
701 .rates = SNDRV_PCM_RATE_48000,
702 .formats = SNDRV_PCM_FORMAT_S16_LE,
709 .ops = &gbcodec_dai_ops,
713 static int gbaudio_init_jack(struct gbaudio_module_info *module,
714 struct snd_soc_codec *codec)
718 if (!module->jack_mask)
721 snprintf(module->jack_name, NAME_SIZE, "GB %d Headset Jack",
723 ret = snd_soc_jack_new(codec, module->jack_name, module->jack_mask,
724 &module->headset_jack);
726 dev_err(module->dev, "Failed to create new jack\n");
730 if (!module->button_mask)
733 snprintf(module->button_name, NAME_SIZE, "GB %d Button Jack",
735 ret = snd_soc_jack_new(codec, module->button_name, module->button_mask,
736 &module->button_jack);
738 dev_err(module->dev, "Failed to create button jack\n");
743 * Currently, max 4 buttons are supported with following key mapping
745 * BTN_1 = KEY_VOICECOMMAND
746 * BTN_2 = KEY_VOLUMEUP
747 * BTN_3 = KEY_VOLUMEDOWN
750 if (module->button_mask & SND_JACK_BTN_0) {
751 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_0,
754 dev_err(module->dev, "Failed to set BTN_0\n");
759 if (module->button_mask & SND_JACK_BTN_1) {
760 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_1,
763 dev_err(module->dev, "Failed to set BTN_1\n");
768 if (module->button_mask & SND_JACK_BTN_2) {
769 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_2,
772 dev_err(module->dev, "Failed to set BTN_2\n");
777 if (module->button_mask & SND_JACK_BTN_3) {
778 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_3,
781 dev_err(module->dev, "Failed to set BTN_0\n");
787 * verify if this is really required
788 set_bit(INPUT_PROP_NO_DUMMY_RELEASE,
789 module->button_jack.jack->input_dev->propbit);
795 int gbaudio_register_module(struct gbaudio_module_info *module)
798 struct snd_soc_codec *codec;
799 struct snd_card *card;
800 struct snd_soc_jack *jack = NULL;
803 dev_err(module->dev, "GB Codec not yet probed\n");
807 codec = gbcodec->codec;
808 card = codec->card->snd_card;
810 down_write(&card->controls_rwsem);
812 if (module->num_dais) {
813 dev_err(gbcodec->dev,
814 "%d:DAIs not supported via gbcodec driver\n",
816 up_write(&card->controls_rwsem);
820 ret = gbaudio_init_jack(module, codec);
822 up_write(&card->controls_rwsem);
826 if (module->dapm_widgets)
827 snd_soc_dapm_new_controls(&codec->dapm, module->dapm_widgets,
828 module->num_dapm_widgets);
829 if (module->controls)
830 snd_soc_add_codec_controls(codec, module->controls,
831 module->num_controls);
832 if (module->dapm_routes)
833 snd_soc_dapm_add_routes(&codec->dapm, module->dapm_routes,
834 module->num_dapm_routes);
836 /* card already instantiated, create widgets here only */
837 if (codec->card->instantiated) {
838 snd_soc_dapm_link_component_dai_widgets(codec->card,
840 #ifdef CONFIG_SND_JACK
842 * register jack devices for this module
843 * from codec->jack_list
845 list_for_each_entry(jack, &codec->jack_list, list) {
846 if ((jack == &module->headset_jack) ||
847 (jack == &module->button_jack))
848 snd_device_register(codec->card->snd_card,
854 mutex_lock(&gbcodec->lock);
855 list_add(&module->list, &gbcodec->module_list);
856 mutex_unlock(&gbcodec->lock);
858 if (codec->card->instantiated)
859 ret = snd_soc_dapm_new_widgets(&codec->dapm);
860 dev_dbg(codec->dev, "Registered %s module\n", module->name);
862 up_write(&card->controls_rwsem);
865 EXPORT_SYMBOL(gbaudio_register_module);
867 static void gbaudio_codec_clean_data_tx(struct gbaudio_data_connection *data)
869 u16 i2s_port, cportid;
872 if (list_is_singular(&gbcodec->module_list)) {
873 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
876 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
881 i2s_port = 0; /* fixed for now */
882 cportid = data->connection->hd_cport_id;
883 ret = gb_audio_apbridgea_unregister_cport(data->connection,
885 AUDIO_APBRIDGEA_DIRECTION_TX);
886 data->state[0] = GBAUDIO_CODEC_SHUTDOWN;
889 static void gbaudio_codec_clean_data_rx(struct gbaudio_data_connection *data)
891 u16 i2s_port, cportid;
894 if (list_is_singular(&gbcodec->module_list)) {
895 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
898 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
903 i2s_port = 0; /* fixed for now */
904 cportid = data->connection->hd_cport_id;
905 ret = gb_audio_apbridgea_unregister_cport(data->connection,
907 AUDIO_APBRIDGEA_DIRECTION_RX);
908 data->state[1] = GBAUDIO_CODEC_SHUTDOWN;
911 static void gbaudio_codec_cleanup(struct gbaudio_module_info *module)
913 struct gbaudio_data_connection *data;
914 int pb_state, cap_state;
916 dev_dbg(gbcodec->dev, "%s: removed, cleanup APBridge\n", module->name);
917 list_for_each_entry(data, &module->data_list, list) {
918 pb_state = data->state[0];
919 cap_state = data->state[1];
921 if (pb_state > GBAUDIO_CODEC_SHUTDOWN)
922 gbaudio_codec_clean_data_tx(data);
924 if (cap_state > GBAUDIO_CODEC_SHUTDOWN)
925 gbaudio_codec_clean_data_rx(data);
929 void gbaudio_unregister_module(struct gbaudio_module_info *module)
931 struct snd_soc_codec *codec = gbcodec->codec;
932 struct snd_card *card = codec->card->snd_card;
933 struct snd_soc_jack *jack, *next_j;
936 dev_dbg(codec->dev, "Unregister %s module\n", module->name);
938 down_write(&card->controls_rwsem);
939 mutex_lock(&gbcodec->lock);
940 gbaudio_codec_cleanup(module);
941 list_del(&module->list);
942 dev_dbg(codec->dev, "Process Unregister %s module\n", module->name);
943 mutex_unlock(&gbcodec->lock);
945 #ifdef CONFIG_SND_JACK
946 /* free jack devices for this module from codec->jack_list */
947 list_for_each_entry_safe(jack, next_j, &codec->jack_list, list) {
948 if (jack == &module->headset_jack)
949 mask = GBCODEC_JACK_MASK;
950 else if (jack == &module->button_jack)
951 mask = GBCODEC_JACK_BUTTON_MASK;
955 dev_dbg(module->dev, "Report %s removal\n",
957 snd_soc_jack_report(jack, 0, mask);
958 snd_device_free(codec->card->snd_card, jack->jack);
959 list_del(&jack->list);
964 if (module->dapm_routes) {
965 dev_dbg(codec->dev, "Removing %d routes\n",
966 module->num_dapm_routes);
967 snd_soc_dapm_del_routes(&codec->dapm, module->dapm_routes,
968 module->num_dapm_routes);
970 if (module->controls) {
971 dev_dbg(codec->dev, "Removing %d controls\n",
972 module->num_controls);
973 snd_soc_remove_codec_controls(codec, module->controls,
974 module->num_controls);
976 if (module->dapm_widgets) {
977 dev_dbg(codec->dev, "Removing %d widgets\n",
978 module->num_dapm_widgets);
979 snd_soc_dapm_free_controls(&codec->dapm, module->dapm_widgets,
980 module->num_dapm_widgets);
983 dev_dbg(codec->dev, "Unregistered %s module\n", module->name);
985 up_write(&card->controls_rwsem);
987 EXPORT_SYMBOL(gbaudio_unregister_module);
992 static int gbcodec_probe(struct snd_soc_codec *codec)
995 struct gbaudio_codec_info *info;
996 struct gbaudio_codec_dai *dai;
998 info = devm_kzalloc(codec->dev, sizeof(*info), GFP_KERNEL);
1002 info->dev = codec->dev;
1003 INIT_LIST_HEAD(&info->module_list);
1004 mutex_init(&info->lock);
1005 INIT_LIST_HEAD(&info->dai_list);
1007 /* init dai_list used to maintain runtime stream info */
1008 for (i = 0; i < ARRAY_SIZE(gbaudio_dai); i++) {
1009 dai = devm_kzalloc(codec->dev, sizeof(*dai), GFP_KERNEL);
1012 dai->id = gbaudio_dai[i].id;
1013 list_add(&dai->list, &info->dai_list);
1016 info->codec = codec;
1017 snd_soc_codec_set_drvdata(codec, info);
1020 device_init_wakeup(codec->dev, 1);
1024 static int gbcodec_remove(struct snd_soc_codec *codec)
1026 /* Empty function for now */
1030 static int gbcodec_write(struct snd_soc_codec *codec, unsigned int reg,
1036 static unsigned int gbcodec_read(struct snd_soc_codec *codec,
1042 static struct snd_soc_codec_driver soc_codec_dev_gbaudio = {
1043 .probe = gbcodec_probe,
1044 .remove = gbcodec_remove,
1046 .read = gbcodec_read,
1047 .write = gbcodec_write,
1049 .idle_bias_off = true,
1050 .ignore_pmdown_time = 1,
1054 static int gbaudio_codec_suspend(struct device *dev)
1056 dev_dbg(dev, "%s: suspend\n", __func__);
1060 static int gbaudio_codec_resume(struct device *dev)
1062 dev_dbg(dev, "%s: resume\n", __func__);
1066 static const struct dev_pm_ops gbaudio_codec_pm_ops = {
1067 .suspend = gbaudio_codec_suspend,
1068 .resume = gbaudio_codec_resume,
1072 static int gbaudio_codec_probe(struct platform_device *pdev)
1074 return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_gbaudio,
1075 gbaudio_dai, ARRAY_SIZE(gbaudio_dai));
1078 static int gbaudio_codec_remove(struct platform_device *pdev)
1080 snd_soc_unregister_codec(&pdev->dev);
1084 static const struct of_device_id greybus_asoc_machine_of_match[] = {
1085 { .compatible = "toshiba,apb-dummy-codec", },
1089 static struct platform_driver gbaudio_codec_driver = {
1091 .name = "apb-dummy-codec",
1092 .owner = THIS_MODULE,
1094 .pm = &gbaudio_codec_pm_ops,
1096 .of_match_table = greybus_asoc_machine_of_match,
1098 .probe = gbaudio_codec_probe,
1099 .remove = gbaudio_codec_remove,
1101 module_platform_driver(gbaudio_codec_driver);
1103 MODULE_DESCRIPTION("APBridge ALSA SoC dummy codec driver");
1104 MODULE_AUTHOR("Vaibhav Agarwal <vaibhav.agarwal@linaro.org>");
1105 MODULE_LICENSE("GPL v2");
1106 MODULE_ALIAS("platform:apb-dummy-codec");