2 * APBridge ALSA SoC dummy codec driver
3 * Copyright 2016 Google Inc.
4 * Copyright 2016 Linaro Ltd.
6 * Released under the GPLv2 only.
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/pm_runtime.h>
11 #include <sound/soc.h>
12 #include <sound/pcm_params.h>
13 #include <uapi/linux/input.h>
15 #include "audio_codec.h"
16 #include "audio_apbridgea.h"
17 #include "audio_manager.h"
19 static struct gbaudio_codec_info *gbcodec;
21 static struct gbaudio_data_connection *
22 find_data(struct gbaudio_module_info *module, int id)
24 struct gbaudio_data_connection *data;
26 list_for_each_entry(data, &module->data_list, list) {
33 static struct gbaudio_stream_params *
34 find_dai_stream_params(struct gbaudio_codec_info *codec, int id, int stream)
36 struct gbaudio_codec_dai *dai;
38 list_for_each_entry(dai, &codec->dai_list, list) {
40 return &dai->params[stream];
45 static int gbaudio_module_enable_tx(struct gbaudio_codec_info *codec,
46 struct gbaudio_module_info *module, int id)
48 int module_state, ret = 0;
49 u16 data_cport, i2s_port, cportid;
50 u8 sig_bits, channels;
51 uint32_t format, rate;
52 struct gbaudio_data_connection *data;
53 struct gbaudio_stream_params *params;
56 data = find_data(module, id);
58 dev_err(module->dev, "%d:DATA connection missing\n", id);
61 module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
63 params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_PLAYBACK);
65 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
70 if (module_state < GBAUDIO_CODEC_STARTUP) {
71 i2s_port = 0; /* fixed for now */
72 cportid = data->connection->hd_cport_id;
73 ret = gb_audio_apbridgea_register_cport(data->connection,
75 AUDIO_APBRIDGEA_DIRECTION_TX);
77 dev_err_ratelimited(module->dev,
78 "reg_cport failed:%d\n", ret);
81 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
82 GBAUDIO_CODEC_STARTUP;
83 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
87 if (module_state < GBAUDIO_CODEC_HWPARAMS) {
88 format = params->format;
89 channels = params->channels;
91 sig_bits = params->sig_bits;
92 data_cport = data->connection->intf_cport_id;
93 ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
94 format, rate, channels, sig_bits);
96 dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
100 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
101 GBAUDIO_CODEC_HWPARAMS;
102 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
106 if (module_state < GBAUDIO_CODEC_PREPARE) {
107 data_cport = data->connection->intf_cport_id;
108 ret = gb_audio_gb_set_tx_data_size(module->mgmt_connection,
111 dev_err_ratelimited(module->dev,
112 "set_tx_data_size failed:%d\n",
116 ret = gb_audio_gb_activate_tx(module->mgmt_connection,
119 dev_err_ratelimited(module->dev,
120 "activate_tx failed:%d\n", ret);
123 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
124 GBAUDIO_CODEC_PREPARE;
125 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
131 static int gbaudio_module_disable_tx(struct gbaudio_module_info *module, int id)
134 u16 data_cport, cportid, i2s_port;
136 struct gbaudio_data_connection *data;
139 data = find_data(module, id);
141 dev_err(module->dev, "%d:DATA connection missing\n", id);
144 module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
146 if (module_state > GBAUDIO_CODEC_HWPARAMS) {
147 data_cport = data->connection->intf_cport_id;
148 ret = gb_audio_gb_deactivate_tx(module->mgmt_connection,
151 dev_err_ratelimited(module->dev,
152 "deactivate_tx failed:%d\n", ret);
155 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
156 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
157 GBAUDIO_CODEC_HWPARAMS;
160 if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
161 i2s_port = 0; /* fixed for now */
162 cportid = data->connection->hd_cport_id;
163 ret = gb_audio_apbridgea_unregister_cport(data->connection,
165 AUDIO_APBRIDGEA_DIRECTION_TX);
167 dev_err_ratelimited(module->dev,
168 "unregister_cport failed:%d\n",
172 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
173 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
174 GBAUDIO_CODEC_SHUTDOWN;
180 static int gbaudio_module_enable_rx(struct gbaudio_codec_info *codec,
181 struct gbaudio_module_info *module, int id)
183 int module_state, ret = 0;
184 u16 data_cport, i2s_port, cportid;
185 u8 sig_bits, channels;
186 uint32_t format, rate;
187 struct gbaudio_data_connection *data;
188 struct gbaudio_stream_params *params;
191 data = find_data(module, id);
193 dev_err(module->dev, "%d:DATA connection missing\n", id);
196 module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
198 params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_CAPTURE);
200 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
205 if (module_state < GBAUDIO_CODEC_STARTUP) {
206 i2s_port = 0; /* fixed for now */
207 cportid = data->connection->hd_cport_id;
208 ret = gb_audio_apbridgea_register_cport(data->connection,
210 AUDIO_APBRIDGEA_DIRECTION_RX);
212 dev_err_ratelimited(module->dev,
213 "reg_cport failed:%d\n", ret);
216 data->state[SNDRV_PCM_STREAM_CAPTURE] =
217 GBAUDIO_CODEC_STARTUP;
218 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
222 if (module_state < GBAUDIO_CODEC_HWPARAMS) {
223 format = params->format;
224 channels = params->channels;
226 sig_bits = params->sig_bits;
227 data_cport = data->connection->intf_cport_id;
228 ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
229 format, rate, channels, sig_bits);
231 dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
235 data->state[SNDRV_PCM_STREAM_CAPTURE] =
236 GBAUDIO_CODEC_HWPARAMS;
237 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
241 if (module_state < GBAUDIO_CODEC_PREPARE) {
242 data_cport = data->connection->intf_cport_id;
243 ret = gb_audio_gb_set_rx_data_size(module->mgmt_connection,
246 dev_err_ratelimited(module->dev,
247 "set_rx_data_size failed:%d\n",
251 ret = gb_audio_gb_activate_rx(module->mgmt_connection,
254 dev_err_ratelimited(module->dev,
255 "activate_rx failed:%d\n", ret);
258 data->state[SNDRV_PCM_STREAM_CAPTURE] =
259 GBAUDIO_CODEC_PREPARE;
260 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
266 static int gbaudio_module_disable_rx(struct gbaudio_module_info *module, int id)
269 u16 data_cport, cportid, i2s_port;
271 struct gbaudio_data_connection *data;
274 data = find_data(module, id);
276 dev_err(module->dev, "%d:DATA connection missing\n", id);
279 module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
281 if (module_state > GBAUDIO_CODEC_HWPARAMS) {
282 data_cport = data->connection->intf_cport_id;
283 ret = gb_audio_gb_deactivate_rx(module->mgmt_connection,
286 dev_err_ratelimited(module->dev,
287 "deactivate_rx failed:%d\n", ret);
290 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
291 data->state[SNDRV_PCM_STREAM_CAPTURE] =
292 GBAUDIO_CODEC_HWPARAMS;
295 if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
296 i2s_port = 0; /* fixed for now */
297 cportid = data->connection->hd_cport_id;
298 ret = gb_audio_apbridgea_unregister_cport(data->connection,
300 AUDIO_APBRIDGEA_DIRECTION_RX);
302 dev_err_ratelimited(module->dev,
303 "unregister_cport failed:%d\n",
307 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
308 data->state[SNDRV_PCM_STREAM_CAPTURE] =
309 GBAUDIO_CODEC_SHUTDOWN;
315 int gbaudio_module_update(struct gbaudio_codec_info *codec,
316 struct snd_soc_dapm_widget *w,
317 struct gbaudio_module_info *module, int enable)
320 char intf_name[NAME_SIZE], dir[NAME_SIZE];
322 dev_dbg(module->dev, "%s:Module update %s sequence\n", w->name,
323 enable ? "Enable":"Disable");
325 if ((w->id != snd_soc_dapm_aif_in) && (w->id != snd_soc_dapm_aif_out)) {
326 dev_dbg(codec->dev, "No action required for %s\n", w->name);
330 /* parse dai_id from AIF widget's stream_name */
331 ret = sscanf(w->sname, "%s %d %s", intf_name, &dai_id, dir);
333 dev_err(codec->dev, "Error while parsing dai_id for %s\n",
338 mutex_lock(&codec->lock);
339 if (w->id == snd_soc_dapm_aif_in) {
341 ret = gbaudio_module_enable_tx(codec, module, dai_id);
343 ret = gbaudio_module_disable_tx(module, dai_id);
344 } else if (w->id == snd_soc_dapm_aif_out) {
346 ret = gbaudio_module_enable_rx(codec, module, dai_id);
348 ret = gbaudio_module_disable_rx(module, dai_id);
351 mutex_unlock(&codec->lock);
355 EXPORT_SYMBOL(gbaudio_module_update);
360 static int gbcodec_startup(struct snd_pcm_substream *substream,
361 struct snd_soc_dai *dai)
363 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
364 struct gbaudio_stream_params *params;
366 mutex_lock(&codec->lock);
368 if (list_empty(&codec->module_list)) {
369 dev_err(codec->dev, "No codec module available\n");
370 mutex_unlock(&codec->lock);
374 params = find_dai_stream_params(codec, dai->id, substream->stream);
376 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
377 mutex_unlock(&codec->lock);
380 params->state = GBAUDIO_CODEC_STARTUP;
381 mutex_unlock(&codec->lock);
382 /* to prevent suspend in case of active audio */
383 pm_stay_awake(dai->dev);
388 static void gbcodec_shutdown(struct snd_pcm_substream *substream,
389 struct snd_soc_dai *dai)
391 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
392 struct gbaudio_stream_params *params;
394 mutex_lock(&codec->lock);
396 if (list_empty(&codec->module_list))
397 dev_info(codec->dev, "No codec module available during shutdown\n");
399 params = find_dai_stream_params(codec, dai->id, substream->stream);
401 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
402 mutex_unlock(&codec->lock);
405 params->state = GBAUDIO_CODEC_SHUTDOWN;
406 mutex_unlock(&codec->lock);
411 static int gbcodec_hw_params(struct snd_pcm_substream *substream,
412 struct snd_pcm_hw_params *hwparams,
413 struct snd_soc_dai *dai)
416 u8 sig_bits, channels;
417 uint32_t format, rate;
418 struct gbaudio_module_info *module;
419 struct gbaudio_data_connection *data;
420 struct gb_bundle *bundle;
421 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
422 struct gbaudio_stream_params *params;
424 mutex_lock(&codec->lock);
426 if (list_empty(&codec->module_list)) {
427 dev_err(codec->dev, "No codec module available\n");
428 mutex_unlock(&codec->lock);
433 * assuming, currently only 48000 Hz, 16BIT_LE, stereo
434 * is supported, validate params before configuring codec
436 if (params_channels(hwparams) != 2) {
437 dev_err(dai->dev, "Invalid channel count:%d\n",
438 params_channels(hwparams));
439 mutex_unlock(&codec->lock);
442 channels = params_channels(hwparams);
444 if (params_rate(hwparams) != 48000) {
445 dev_err(dai->dev, "Invalid sampling rate:%d\n",
446 params_rate(hwparams));
447 mutex_unlock(&codec->lock);
450 rate = GB_AUDIO_PCM_RATE_48000;
452 if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) {
453 dev_err(dai->dev, "Invalid format:%d\n",
454 params_format(hwparams));
455 mutex_unlock(&codec->lock);
458 format = GB_AUDIO_PCM_FMT_S16_LE;
460 /* find the data connection */
461 list_for_each_entry(module, &codec->module_list, list) {
462 data = find_data(module, dai->id);
468 dev_err(dai->dev, "DATA connection missing\n");
469 mutex_unlock(&codec->lock);
473 params = find_dai_stream_params(codec, dai->id, substream->stream);
475 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
476 mutex_unlock(&codec->lock);
480 bundle = to_gb_bundle(module->dev);
481 ret = gb_pm_runtime_get_sync(bundle);
483 mutex_unlock(&codec->lock);
487 ret = gb_audio_apbridgea_set_config(data->connection, 0,
488 AUDIO_APBRIDGEA_PCM_FMT_16,
489 AUDIO_APBRIDGEA_PCM_RATE_48000,
492 dev_err_ratelimited(dai->dev, "%d: Error during set_config\n",
494 gb_pm_runtime_put_noidle(bundle);
495 mutex_unlock(&codec->lock);
499 gb_pm_runtime_put_noidle(bundle);
501 params->state = GBAUDIO_CODEC_HWPARAMS;
502 params->format = format;
504 params->channels = channels;
505 params->sig_bits = sig_bits;
507 mutex_unlock(&codec->lock);
511 static int gbcodec_prepare(struct snd_pcm_substream *substream,
512 struct snd_soc_dai *dai)
515 struct gbaudio_module_info *module;
516 struct gbaudio_data_connection *data;
517 struct gb_bundle *bundle;
518 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
519 struct gbaudio_stream_params *params;
521 mutex_lock(&codec->lock);
523 if (list_empty(&codec->module_list)) {
524 dev_err(codec->dev, "No codec module available\n");
525 mutex_unlock(&codec->lock);
529 list_for_each_entry(module, &codec->module_list, list) {
531 data = find_data(module, dai->id);
536 dev_err(dai->dev, "DATA connection missing\n");
537 mutex_unlock(&codec->lock);
541 params = find_dai_stream_params(codec, dai->id, substream->stream);
543 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
544 mutex_unlock(&codec->lock);
548 bundle = to_gb_bundle(module->dev);
549 ret = gb_pm_runtime_get_sync(bundle);
551 mutex_unlock(&codec->lock);
555 switch (substream->stream) {
556 case SNDRV_PCM_STREAM_PLAYBACK:
557 ret = gb_audio_apbridgea_set_tx_data_size(data->connection, 0,
560 case SNDRV_PCM_STREAM_CAPTURE:
561 ret = gb_audio_apbridgea_set_rx_data_size(data->connection, 0,
566 gb_pm_runtime_put_noidle(bundle);
567 mutex_unlock(&codec->lock);
568 dev_err_ratelimited(dai->dev, "set_data_size failed:%d\n",
573 gb_pm_runtime_put_noidle(bundle);
575 params->state = GBAUDIO_CODEC_PREPARE;
576 mutex_unlock(&codec->lock);
580 static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
583 struct gbaudio_data_connection *data;
584 struct gbaudio_module_info *module;
585 struct gb_bundle *bundle;
586 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
587 struct gbaudio_stream_params *params;
590 dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
591 stream ? "CAPTURE":"PLAYBACK");
593 mutex_lock(&codec->lock);
595 params = find_dai_stream_params(codec, dai->id, stream);
597 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
598 mutex_unlock(&codec->lock);
602 if (list_empty(&codec->module_list)) {
603 dev_err(codec->dev, "No codec module available\n");
605 params->state = GBAUDIO_CODEC_STOP;
610 mutex_unlock(&codec->lock);
614 list_for_each_entry(module, &codec->module_list, list) {
616 data = find_data(module, dai->id);
621 dev_err(dai->dev, "%s:%s DATA connection missing\n",
622 dai->name, module->name);
623 mutex_unlock(&codec->lock);
627 bundle = to_gb_bundle(module->dev);
628 ret = gb_pm_runtime_get_sync(bundle);
630 mutex_unlock(&codec->lock);
634 if (!mute && !stream) {/* start playback */
635 ret = gb_audio_apbridgea_prepare_tx(data->connection,
638 ret = gb_audio_apbridgea_start_tx(data->connection,
640 params->state = GBAUDIO_CODEC_START;
641 } else if (!mute && stream) {/* start capture */
642 ret = gb_audio_apbridgea_prepare_rx(data->connection,
645 ret = gb_audio_apbridgea_start_rx(data->connection,
647 params->state = GBAUDIO_CODEC_START;
648 } else if (mute && !stream) {/* stop playback */
649 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
651 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
653 params->state = GBAUDIO_CODEC_STOP;
654 } else if (mute && stream) {/* stop capture */
655 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
657 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
659 params->state = GBAUDIO_CODEC_STOP;
663 dev_err_ratelimited(dai->dev,
664 "%s:Error during %s %s stream:%d\n",
665 module->name, mute ? "Mute" : "Unmute",
666 stream ? "Capture" : "Playback", ret);
668 gb_pm_runtime_put_noidle(bundle);
669 mutex_unlock(&codec->lock);
673 static struct snd_soc_dai_ops gbcodec_dai_ops = {
674 .startup = gbcodec_startup,
675 .shutdown = gbcodec_shutdown,
676 .hw_params = gbcodec_hw_params,
677 .prepare = gbcodec_prepare,
678 .mute_stream = gbcodec_mute_stream,
681 static struct snd_soc_dai_driver gbaudio_dai[] = {
686 .stream_name = "I2S 0 Playback",
687 .rates = SNDRV_PCM_RATE_48000,
688 .formats = SNDRV_PCM_FORMAT_S16_LE,
695 .stream_name = "I2S 0 Capture",
696 .rates = SNDRV_PCM_RATE_48000,
697 .formats = SNDRV_PCM_FORMAT_S16_LE,
703 .ops = &gbcodec_dai_ops,
707 static int gbaudio_init_jack(struct gbaudio_module_info *module,
708 struct snd_soc_codec *codec)
712 if (!module->jack_mask)
715 snprintf(module->jack_name, NAME_SIZE, "GB %d Headset Jack",
717 ret = snd_soc_jack_new(codec, module->jack_name, module->jack_mask,
718 &module->headset_jack);
720 dev_err(module->dev, "Failed to create new jack\n");
724 if (!module->button_mask)
727 snprintf(module->button_name, NAME_SIZE, "GB %d Button Jack",
729 ret = snd_soc_jack_new(codec, module->button_name, module->button_mask,
730 &module->button_jack);
732 dev_err(module->dev, "Failed to create button jack\n");
737 * Currently, max 4 buttons are supported with following key mapping
739 * BTN_1 = KEY_VOICECOMMAND
740 * BTN_2 = KEY_VOLUMEUP
741 * BTN_3 = KEY_VOLUMEDOWN
744 if (module->button_mask & SND_JACK_BTN_0) {
745 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_0,
748 dev_err(module->dev, "Failed to set BTN_0\n");
753 if (module->button_mask & SND_JACK_BTN_1) {
754 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_1,
757 dev_err(module->dev, "Failed to set BTN_1\n");
762 if (module->button_mask & SND_JACK_BTN_2) {
763 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_2,
766 dev_err(module->dev, "Failed to set BTN_2\n");
771 if (module->button_mask & SND_JACK_BTN_3) {
772 ret = snd_jack_set_key(module->button_jack.jack, SND_JACK_BTN_3,
775 dev_err(module->dev, "Failed to set BTN_0\n");
781 * verify if this is really required
782 set_bit(INPUT_PROP_NO_DUMMY_RELEASE,
783 module->button_jack.jack->input_dev->propbit);
789 int gbaudio_register_module(struct gbaudio_module_info *module)
792 struct snd_soc_codec *codec;
793 struct snd_card *card;
794 struct snd_soc_jack *jack = NULL;
797 dev_err(module->dev, "GB Codec not yet probed\n");
801 codec = gbcodec->codec;
802 card = codec->card->snd_card;
804 down_write(&card->controls_rwsem);
806 if (module->num_dais) {
807 dev_err(gbcodec->dev,
808 "%d:DAIs not supported via gbcodec driver\n",
810 up_write(&card->controls_rwsem);
814 ret = gbaudio_init_jack(module, codec);
816 up_write(&card->controls_rwsem);
820 if (module->dapm_widgets)
821 snd_soc_dapm_new_controls(&codec->dapm, module->dapm_widgets,
822 module->num_dapm_widgets);
823 if (module->controls)
824 snd_soc_add_codec_controls(codec, module->controls,
825 module->num_controls);
826 if (module->dapm_routes)
827 snd_soc_dapm_add_routes(&codec->dapm, module->dapm_routes,
828 module->num_dapm_routes);
830 /* card already instantiated, create widgets here only */
831 if (codec->card->instantiated) {
832 snd_soc_dapm_link_component_dai_widgets(codec->card,
834 #ifdef CONFIG_SND_JACK
835 /* register jack devices for this module from codec->jack_list */
836 list_for_each_entry(jack, &codec->jack_list, list) {
837 if ((jack == &module->headset_jack)
838 || (jack == &module->button_jack))
839 snd_device_register(codec->card->snd_card,
845 mutex_lock(&gbcodec->lock);
846 list_add(&module->list, &gbcodec->module_list);
847 mutex_unlock(&gbcodec->lock);
849 if (codec->card->instantiated)
850 ret = snd_soc_dapm_new_widgets(&codec->dapm);
851 dev_dbg(codec->dev, "Registered %s module\n", module->name);
853 up_write(&card->controls_rwsem);
856 EXPORT_SYMBOL(gbaudio_register_module);
858 static void gbaudio_codec_clean_data_tx(struct gbaudio_data_connection *data)
860 u16 i2s_port, cportid;
863 if (list_is_singular(&gbcodec->module_list)) {
864 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
867 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
872 i2s_port = 0; /* fixed for now */
873 cportid = data->connection->hd_cport_id;
874 ret = gb_audio_apbridgea_unregister_cport(data->connection,
876 AUDIO_APBRIDGEA_DIRECTION_TX);
877 data->state[0] = GBAUDIO_CODEC_SHUTDOWN;
880 static void gbaudio_codec_clean_data_rx(struct gbaudio_data_connection *data)
882 u16 i2s_port, cportid;
885 if (list_is_singular(&gbcodec->module_list)) {
886 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
889 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
894 i2s_port = 0; /* fixed for now */
895 cportid = data->connection->hd_cport_id;
896 ret = gb_audio_apbridgea_unregister_cport(data->connection,
898 AUDIO_APBRIDGEA_DIRECTION_RX);
899 data->state[1] = GBAUDIO_CODEC_SHUTDOWN;
903 static void gbaudio_codec_cleanup(struct gbaudio_module_info *module)
905 struct gbaudio_data_connection *data;
906 int pb_state, cap_state;
908 dev_dbg(gbcodec->dev, "%s: removed, cleanup APBridge\n", module->name);
909 list_for_each_entry(data, &module->data_list, list) {
910 pb_state = data->state[0];
911 cap_state = data->state[1];
913 if (pb_state > GBAUDIO_CODEC_SHUTDOWN)
914 gbaudio_codec_clean_data_tx(data);
916 if (cap_state > GBAUDIO_CODEC_SHUTDOWN)
917 gbaudio_codec_clean_data_rx(data);
922 void gbaudio_unregister_module(struct gbaudio_module_info *module)
924 struct snd_soc_codec *codec = gbcodec->codec;
925 struct snd_card *card = codec->card->snd_card;
926 struct snd_soc_jack *jack, *next_j;
929 dev_dbg(codec->dev, "Unregister %s module\n", module->name);
931 down_write(&card->controls_rwsem);
932 mutex_lock(&gbcodec->lock);
933 gbaudio_codec_cleanup(module);
934 list_del(&module->list);
935 dev_dbg(codec->dev, "Process Unregister %s module\n", module->name);
936 mutex_unlock(&gbcodec->lock);
938 #ifdef CONFIG_SND_JACK
939 /* free jack devices for this module from codec->jack_list */
940 list_for_each_entry_safe(jack, next_j, &codec->jack_list, list) {
941 if (jack == &module->headset_jack)
942 mask = GBCODEC_JACK_MASK;
943 else if (jack == &module->button_jack)
944 mask = GBCODEC_JACK_BUTTON_MASK;
948 dev_dbg(module->dev, "Report %s removal\n",
950 snd_soc_jack_report(jack, 0, mask);
951 snd_device_free(codec->card->snd_card, jack->jack);
952 list_del(&jack->list);
957 if (module->dapm_routes) {
958 dev_dbg(codec->dev, "Removing %d routes\n",
959 module->num_dapm_routes);
960 snd_soc_dapm_del_routes(&codec->dapm, module->dapm_routes,
961 module->num_dapm_routes);
963 if (module->controls) {
964 dev_dbg(codec->dev, "Removing %d controls\n",
965 module->num_controls);
966 snd_soc_remove_codec_controls(codec, module->controls,
967 module->num_controls);
969 if (module->dapm_widgets) {
970 dev_dbg(codec->dev, "Removing %d widgets\n",
971 module->num_dapm_widgets);
972 snd_soc_dapm_free_controls(&codec->dapm, module->dapm_widgets,
973 module->num_dapm_widgets);
976 dev_dbg(codec->dev, "Unregistered %s module\n", module->name);
978 up_write(&card->controls_rwsem);
980 EXPORT_SYMBOL(gbaudio_unregister_module);
985 static int gbcodec_probe(struct snd_soc_codec *codec)
988 struct gbaudio_codec_info *info;
989 struct gbaudio_codec_dai *dai;
991 info = devm_kzalloc(codec->dev, sizeof(*info), GFP_KERNEL);
995 info->dev = codec->dev;
996 INIT_LIST_HEAD(&info->module_list);
997 mutex_init(&info->lock);
998 INIT_LIST_HEAD(&info->dai_list);
1000 /* init dai_list used to maintain runtime stream info */
1001 for (i = 0; i < ARRAY_SIZE(gbaudio_dai); i++) {
1002 dai = devm_kzalloc(codec->dev, sizeof(*dai), GFP_KERNEL);
1005 dai->id = gbaudio_dai[i].id;
1006 list_add(&dai->list, &info->dai_list);
1009 info->codec = codec;
1010 snd_soc_codec_set_drvdata(codec, info);
1013 device_init_wakeup(codec->dev, 1);
1017 static int gbcodec_remove(struct snd_soc_codec *codec)
1019 /* Empty function for now */
1023 static u8 gbcodec_reg[GBCODEC_REG_COUNT] = {
1024 [GBCODEC_CTL_REG] = GBCODEC_CTL_REG_DEFAULT,
1025 [GBCODEC_MUTE_REG] = GBCODEC_MUTE_REG_DEFAULT,
1026 [GBCODEC_PB_LVOL_REG] = GBCODEC_PB_VOL_REG_DEFAULT,
1027 [GBCODEC_PB_RVOL_REG] = GBCODEC_PB_VOL_REG_DEFAULT,
1028 [GBCODEC_CAP_LVOL_REG] = GBCODEC_CAP_VOL_REG_DEFAULT,
1029 [GBCODEC_CAP_RVOL_REG] = GBCODEC_CAP_VOL_REG_DEFAULT,
1030 [GBCODEC_APB1_MUX_REG] = GBCODEC_APB1_MUX_REG_DEFAULT,
1031 [GBCODEC_APB2_MUX_REG] = GBCODEC_APB2_MUX_REG_DEFAULT,
1034 static int gbcodec_write(struct snd_soc_codec *codec, unsigned int reg,
1039 if (reg == SND_SOC_NOPM)
1042 BUG_ON(reg >= GBCODEC_REG_COUNT);
1044 gbcodec_reg[reg] = value;
1045 dev_dbg(codec->dev, "reg[%d] = 0x%x\n", reg, value);
1050 static unsigned int gbcodec_read(struct snd_soc_codec *codec,
1053 unsigned int val = 0;
1055 if (reg == SND_SOC_NOPM)
1058 BUG_ON(reg >= GBCODEC_REG_COUNT);
1060 val = gbcodec_reg[reg];
1061 dev_dbg(codec->dev, "reg[%d] = 0x%x\n", reg, val);
1066 static struct snd_soc_codec_driver soc_codec_dev_gbaudio = {
1067 .probe = gbcodec_probe,
1068 .remove = gbcodec_remove,
1070 .read = gbcodec_read,
1071 .write = gbcodec_write,
1073 .reg_cache_size = GBCODEC_REG_COUNT,
1074 .reg_cache_default = gbcodec_reg_defaults,
1077 .idle_bias_off = true,
1078 .ignore_pmdown_time = 1,
1082 static int gbaudio_codec_suspend(struct device *dev)
1084 dev_dbg(dev, "%s: suspend\n", __func__);
1088 static int gbaudio_codec_resume(struct device *dev)
1090 dev_dbg(dev, "%s: resume\n", __func__);
1094 static const struct dev_pm_ops gbaudio_codec_pm_ops = {
1095 .suspend = gbaudio_codec_suspend,
1096 .resume = gbaudio_codec_resume,
1100 static int gbaudio_codec_probe(struct platform_device *pdev)
1102 return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_gbaudio,
1103 gbaudio_dai, ARRAY_SIZE(gbaudio_dai));
1106 static int gbaudio_codec_remove(struct platform_device *pdev)
1108 snd_soc_unregister_codec(&pdev->dev);
1112 static const struct of_device_id greybus_asoc_machine_of_match[] = {
1113 { .compatible = "toshiba,apb-dummy-codec", },
1117 static struct platform_driver gbaudio_codec_driver = {
1119 .name = "apb-dummy-codec",
1120 .owner = THIS_MODULE,
1122 .pm = &gbaudio_codec_pm_ops,
1124 .of_match_table = greybus_asoc_machine_of_match,
1126 .probe = gbaudio_codec_probe,
1127 .remove = gbaudio_codec_remove,
1129 module_platform_driver(gbaudio_codec_driver);
1131 MODULE_DESCRIPTION("APBridge ALSA SoC dummy codec driver");
1132 MODULE_AUTHOR("Vaibhav Agarwal <vaibhav.agarwal@linaro.org>");
1133 MODULE_LICENSE("GPL v2");
1134 MODULE_ALIAS("platform:apb-dummy-codec");