1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * APBridge ALSA SoC dummy codec driver
4 * Copyright 2016 Google Inc.
5 * Copyright 2016 Linaro Ltd.
6 */
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>
13
14 #include "audio_codec.h"
15 #include "audio_apbridgea.h"
16 #include "audio_manager.h"
17 #include "audio_helper.h"
18
19 static struct gbaudio_codec_info *gbcodec;
20
21 static struct gbaudio_data_connection *
find_data(struct gbaudio_module_info * module,int id)22 find_data(struct gbaudio_module_info *module, int id)
23 {
24 struct gbaudio_data_connection *data;
25
26 list_for_each_entry(data, &module->data_list, list) {
27 if (id == data->id)
28 return data;
29 }
30 return NULL;
31 }
32
33 static struct gbaudio_stream_params *
find_dai_stream_params(struct gbaudio_codec_info * codec,int id,int stream)34 find_dai_stream_params(struct gbaudio_codec_info *codec, int id, int stream)
35 {
36 struct gbaudio_codec_dai *dai;
37
38 list_for_each_entry(dai, &codec->dai_list, list) {
39 if (dai->id == id)
40 return &dai->params[stream];
41 }
42 return NULL;
43 }
44
gbaudio_module_enable_tx(struct gbaudio_codec_info * codec,struct gbaudio_module_info * module,int id)45 static int gbaudio_module_enable_tx(struct gbaudio_codec_info *codec,
46 struct gbaudio_module_info *module, int id)
47 {
48 int module_state, ret = 0;
49 u16 data_cport, i2s_port, cportid;
50 u8 sig_bits, channels;
51 u32 format, rate;
52 struct gbaudio_data_connection *data;
53 struct gbaudio_stream_params *params;
54
55 /* find the dai */
56 data = find_data(module, id);
57 if (!data) {
58 dev_err(module->dev, "%d:DATA connection missing\n", id);
59 return -ENODEV;
60 }
61 module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
62
63 params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_PLAYBACK);
64 if (!params) {
65 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
66 return -EINVAL;
67 }
68
69 /* register cport */
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,
74 i2s_port, cportid,
75 AUDIO_APBRIDGEA_DIRECTION_TX);
76 if (ret) {
77 dev_err_ratelimited(module->dev,
78 "reg_cport failed:%d\n", ret);
79 return ret;
80 }
81 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
82 GBAUDIO_CODEC_STARTUP;
83 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
84 }
85
86 /* hw_params */
87 if (module_state < GBAUDIO_CODEC_HWPARAMS) {
88 format = params->format;
89 channels = params->channels;
90 rate = params->rate;
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);
95 if (ret) {
96 dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
97 ret);
98 return ret;
99 }
100 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
101 GBAUDIO_CODEC_HWPARAMS;
102 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
103 }
104
105 /* prepare */
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,
109 data_cport, 192);
110 if (ret) {
111 dev_err_ratelimited(module->dev,
112 "set_tx_data_size failed:%d\n",
113 ret);
114 return ret;
115 }
116 ret = gb_audio_gb_activate_tx(module->mgmt_connection,
117 data_cport);
118 if (ret) {
119 dev_err_ratelimited(module->dev,
120 "activate_tx failed:%d\n", ret);
121 return ret;
122 }
123 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
124 GBAUDIO_CODEC_PREPARE;
125 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
126 }
127
128 return 0;
129 }
130
gbaudio_module_disable_tx(struct gbaudio_module_info * module,int id)131 static int gbaudio_module_disable_tx(struct gbaudio_module_info *module, int id)
132 {
133 int ret;
134 u16 data_cport, cportid, i2s_port;
135 int module_state;
136 struct gbaudio_data_connection *data;
137
138 /* find the dai */
139 data = find_data(module, id);
140 if (!data) {
141 dev_err(module->dev, "%d:DATA connection missing\n", id);
142 return -ENODEV;
143 }
144 module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
145
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,
149 data_cport);
150 if (ret) {
151 dev_err_ratelimited(module->dev,
152 "deactivate_tx failed:%d\n", ret);
153 return ret;
154 }
155 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
156 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
157 GBAUDIO_CODEC_HWPARAMS;
158 }
159
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,
164 i2s_port, cportid,
165 AUDIO_APBRIDGEA_DIRECTION_TX);
166 if (ret) {
167 dev_err_ratelimited(module->dev,
168 "unregister_cport failed:%d\n",
169 ret);
170 return ret;
171 }
172 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
173 data->state[SNDRV_PCM_STREAM_PLAYBACK] =
174 GBAUDIO_CODEC_SHUTDOWN;
175 }
176
177 return 0;
178 }
179
gbaudio_module_enable_rx(struct gbaudio_codec_info * codec,struct gbaudio_module_info * module,int id)180 static int gbaudio_module_enable_rx(struct gbaudio_codec_info *codec,
181 struct gbaudio_module_info *module, int id)
182 {
183 int module_state, ret = 0;
184 u16 data_cport, i2s_port, cportid;
185 u8 sig_bits, channels;
186 u32 format, rate;
187 struct gbaudio_data_connection *data;
188 struct gbaudio_stream_params *params;
189
190 /* find the dai */
191 data = find_data(module, id);
192 if (!data) {
193 dev_err(module->dev, "%d:DATA connection missing\n", id);
194 return -ENODEV;
195 }
196 module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
197
198 params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_CAPTURE);
199 if (!params) {
200 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
201 return -EINVAL;
202 }
203
204 /* register cport */
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,
209 i2s_port, cportid,
210 AUDIO_APBRIDGEA_DIRECTION_RX);
211 if (ret) {
212 dev_err_ratelimited(module->dev,
213 "reg_cport failed:%d\n", ret);
214 return ret;
215 }
216 data->state[SNDRV_PCM_STREAM_CAPTURE] =
217 GBAUDIO_CODEC_STARTUP;
218 dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
219 }
220
221 /* hw_params */
222 if (module_state < GBAUDIO_CODEC_HWPARAMS) {
223 format = params->format;
224 channels = params->channels;
225 rate = params->rate;
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);
230 if (ret) {
231 dev_err_ratelimited(module->dev, "set_pcm failed:%d\n",
232 ret);
233 return ret;
234 }
235 data->state[SNDRV_PCM_STREAM_CAPTURE] =
236 GBAUDIO_CODEC_HWPARAMS;
237 dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
238 }
239
240 /* prepare */
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,
244 data_cport, 192);
245 if (ret) {
246 dev_err_ratelimited(module->dev,
247 "set_rx_data_size failed:%d\n",
248 ret);
249 return ret;
250 }
251 ret = gb_audio_gb_activate_rx(module->mgmt_connection,
252 data_cport);
253 if (ret) {
254 dev_err_ratelimited(module->dev,
255 "activate_rx failed:%d\n", ret);
256 return ret;
257 }
258 data->state[SNDRV_PCM_STREAM_CAPTURE] =
259 GBAUDIO_CODEC_PREPARE;
260 dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
261 }
262
263 return 0;
264 }
265
gbaudio_module_disable_rx(struct gbaudio_module_info * module,int id)266 static int gbaudio_module_disable_rx(struct gbaudio_module_info *module, int id)
267 {
268 int ret;
269 u16 data_cport, cportid, i2s_port;
270 int module_state;
271 struct gbaudio_data_connection *data;
272
273 /* find the dai */
274 data = find_data(module, id);
275 if (!data) {
276 dev_err(module->dev, "%d:DATA connection missing\n", id);
277 return -ENODEV;
278 }
279 module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
280
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,
284 data_cport);
285 if (ret) {
286 dev_err_ratelimited(module->dev,
287 "deactivate_rx failed:%d\n", ret);
288 return ret;
289 }
290 dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
291 data->state[SNDRV_PCM_STREAM_CAPTURE] =
292 GBAUDIO_CODEC_HWPARAMS;
293 }
294
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,
299 i2s_port, cportid,
300 AUDIO_APBRIDGEA_DIRECTION_RX);
301 if (ret) {
302 dev_err_ratelimited(module->dev,
303 "unregister_cport failed:%d\n",
304 ret);
305 return ret;
306 }
307 dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
308 data->state[SNDRV_PCM_STREAM_CAPTURE] =
309 GBAUDIO_CODEC_SHUTDOWN;
310 }
311
312 return 0;
313 }
314
gbaudio_module_update(struct gbaudio_codec_info * codec,struct snd_soc_dapm_widget * w,struct gbaudio_module_info * module,int enable)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)
318 {
319 int dai_id, ret;
320 char intf_name[NAME_SIZE], dir[NAME_SIZE];
321
322 dev_dbg(module->dev, "%s:Module update %s sequence\n", w->name,
323 enable ? "Enable" : "Disable");
324
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);
327 return 0;
328 }
329
330 /* parse dai_id from AIF widget's stream_name */
331 ret = sscanf(w->sname, "%s %d %s", intf_name, &dai_id, dir);
332 if (ret < 3) {
333 dev_err(codec->dev, "Error while parsing dai_id for %s\n",
334 w->name);
335 return -EINVAL;
336 }
337
338 mutex_lock(&codec->lock);
339 if (w->id == snd_soc_dapm_aif_in) {
340 if (enable)
341 ret = gbaudio_module_enable_tx(codec, module, dai_id);
342 else
343 ret = gbaudio_module_disable_tx(module, dai_id);
344 } else if (w->id == snd_soc_dapm_aif_out) {
345 if (enable)
346 ret = gbaudio_module_enable_rx(codec, module, dai_id);
347 else
348 ret = gbaudio_module_disable_rx(module, dai_id);
349 }
350
351 mutex_unlock(&codec->lock);
352
353 return ret;
354 }
355 EXPORT_SYMBOL(gbaudio_module_update);
356
357 /*
358 * codec DAI ops
359 */
gbcodec_startup(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)360 static int gbcodec_startup(struct snd_pcm_substream *substream,
361 struct snd_soc_dai *dai)
362 {
363 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
364 struct gbaudio_stream_params *params;
365
366 mutex_lock(&codec->lock);
367
368 if (list_empty(&codec->module_list)) {
369 dev_err(codec->dev, "No codec module available\n");
370 mutex_unlock(&codec->lock);
371 return -ENODEV;
372 }
373
374 params = find_dai_stream_params(codec, dai->id, substream->stream);
375 if (!params) {
376 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
377 mutex_unlock(&codec->lock);
378 return -EINVAL;
379 }
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);
384
385 return 0;
386 }
387
gbcodec_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)388 static void gbcodec_shutdown(struct snd_pcm_substream *substream,
389 struct snd_soc_dai *dai)
390 {
391 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
392 struct gbaudio_stream_params *params;
393
394 mutex_lock(&codec->lock);
395
396 if (list_empty(&codec->module_list))
397 dev_info(codec->dev, "No codec module available during shutdown\n");
398
399 params = find_dai_stream_params(codec, dai->id, substream->stream);
400 if (!params) {
401 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
402 mutex_unlock(&codec->lock);
403 return;
404 }
405 params->state = GBAUDIO_CODEC_SHUTDOWN;
406 mutex_unlock(&codec->lock);
407 pm_relax(dai->dev);
408 }
409
gbcodec_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hwparams,struct snd_soc_dai * dai)410 static int gbcodec_hw_params(struct snd_pcm_substream *substream,
411 struct snd_pcm_hw_params *hwparams,
412 struct snd_soc_dai *dai)
413 {
414 int ret;
415 u8 sig_bits, channels;
416 u32 format, rate;
417 struct gbaudio_module_info *module;
418 struct gbaudio_data_connection *data;
419 struct gb_bundle *bundle;
420 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
421 struct gbaudio_stream_params *params;
422
423 mutex_lock(&codec->lock);
424
425 if (list_empty(&codec->module_list)) {
426 dev_err(codec->dev, "No codec module available\n");
427 mutex_unlock(&codec->lock);
428 return -ENODEV;
429 }
430
431 /*
432 * assuming, currently only 48000 Hz, 16BIT_LE, stereo
433 * is supported, validate params before configuring codec
434 */
435 if (params_channels(hwparams) != 2) {
436 dev_err(dai->dev, "Invalid channel count:%d\n",
437 params_channels(hwparams));
438 mutex_unlock(&codec->lock);
439 return -EINVAL;
440 }
441 channels = params_channels(hwparams);
442
443 if (params_rate(hwparams) != 48000) {
444 dev_err(dai->dev, "Invalid sampling rate:%d\n",
445 params_rate(hwparams));
446 mutex_unlock(&codec->lock);
447 return -EINVAL;
448 }
449 rate = GB_AUDIO_PCM_RATE_48000;
450
451 if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) {
452 dev_err(dai->dev, "Invalid format:%d\n",
453 params_format(hwparams));
454 mutex_unlock(&codec->lock);
455 return -EINVAL;
456 }
457 format = GB_AUDIO_PCM_FMT_S16_LE;
458
459 /* find the data connection */
460 list_for_each_entry(module, &codec->module_list, list) {
461 data = find_data(module, dai->id);
462 if (data)
463 break;
464 }
465
466 if (!data) {
467 dev_err(dai->dev, "DATA connection missing\n");
468 mutex_unlock(&codec->lock);
469 return -EINVAL;
470 }
471
472 params = find_dai_stream_params(codec, dai->id, substream->stream);
473 if (!params) {
474 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
475 mutex_unlock(&codec->lock);
476 return -EINVAL;
477 }
478
479 bundle = to_gb_bundle(module->dev);
480 ret = gb_pm_runtime_get_sync(bundle);
481 if (ret) {
482 mutex_unlock(&codec->lock);
483 return ret;
484 }
485
486 ret = gb_audio_apbridgea_set_config(data->connection, 0,
487 AUDIO_APBRIDGEA_PCM_FMT_16,
488 AUDIO_APBRIDGEA_PCM_RATE_48000,
489 6144000);
490 if (ret) {
491 dev_err_ratelimited(dai->dev, "%d: Error during set_config\n",
492 ret);
493 mutex_unlock(&codec->lock);
494 return ret;
495 }
496
497 gb_pm_runtime_put_noidle(bundle);
498
499 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
500 sig_bits = dai->driver->playback.sig_bits;
501 else
502 sig_bits = dai->driver->capture.sig_bits;
503
504 params->state = GBAUDIO_CODEC_HWPARAMS;
505 params->format = format;
506 params->rate = rate;
507 params->channels = channels;
508 params->sig_bits = sig_bits;
509
510 mutex_unlock(&codec->lock);
511 return 0;
512 }
513
gbcodec_prepare(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)514 static int gbcodec_prepare(struct snd_pcm_substream *substream,
515 struct snd_soc_dai *dai)
516 {
517 int ret;
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;
523
524 mutex_lock(&codec->lock);
525
526 if (list_empty(&codec->module_list)) {
527 dev_err(codec->dev, "No codec module available\n");
528 mutex_unlock(&codec->lock);
529 return -ENODEV;
530 }
531
532 list_for_each_entry(module, &codec->module_list, list) {
533 /* find the dai */
534 data = find_data(module, dai->id);
535 if (data)
536 break;
537 }
538 if (!data) {
539 dev_err(dai->dev, "DATA connection missing\n");
540 mutex_unlock(&codec->lock);
541 return -ENODEV;
542 }
543
544 params = find_dai_stream_params(codec, dai->id, substream->stream);
545 if (!params) {
546 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
547 mutex_unlock(&codec->lock);
548 return -EINVAL;
549 }
550
551 bundle = to_gb_bundle(module->dev);
552 ret = gb_pm_runtime_get_sync(bundle);
553 if (ret) {
554 mutex_unlock(&codec->lock);
555 return ret;
556 }
557
558 switch (substream->stream) {
559 case SNDRV_PCM_STREAM_PLAYBACK:
560 ret = gb_audio_apbridgea_set_tx_data_size(data->connection, 0,
561 192);
562 break;
563 case SNDRV_PCM_STREAM_CAPTURE:
564 ret = gb_audio_apbridgea_set_rx_data_size(data->connection, 0,
565 192);
566 break;
567 }
568 if (ret) {
569 mutex_unlock(&codec->lock);
570 dev_err_ratelimited(dai->dev, "set_data_size failed:%d\n",
571 ret);
572 return ret;
573 }
574
575 gb_pm_runtime_put_noidle(bundle);
576
577 params->state = GBAUDIO_CODEC_PREPARE;
578 mutex_unlock(&codec->lock);
579 return 0;
580 }
581
gbcodec_mute_stream(struct snd_soc_dai * dai,int mute,int stream)582 static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
583 {
584 int ret;
585 struct gbaudio_data_connection *data;
586 struct gbaudio_module_info *module;
587 struct gb_bundle *bundle;
588 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
589 struct gbaudio_stream_params *params;
590
591 dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
592 stream ? "CAPTURE" : "PLAYBACK");
593
594 mutex_lock(&codec->lock);
595
596 params = find_dai_stream_params(codec, dai->id, stream);
597 if (!params) {
598 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
599 mutex_unlock(&codec->lock);
600 return -EINVAL;
601 }
602
603 if (list_empty(&codec->module_list)) {
604 dev_err(codec->dev, "No codec module available\n");
605 if (mute) {
606 params->state = GBAUDIO_CODEC_STOP;
607 ret = 0;
608 } else {
609 ret = -ENODEV;
610 }
611 mutex_unlock(&codec->lock);
612 return ret;
613 }
614
615 list_for_each_entry(module, &codec->module_list, list) {
616 /* find the dai */
617 data = find_data(module, dai->id);
618 if (data)
619 break;
620 }
621 if (!data) {
622 dev_err(dai->dev, "%s:%s DATA connection missing\n",
623 dai->name, module->name);
624 mutex_unlock(&codec->lock);
625 return -ENODEV;
626 }
627
628 bundle = to_gb_bundle(module->dev);
629 ret = gb_pm_runtime_get_sync(bundle);
630 if (ret) {
631 mutex_unlock(&codec->lock);
632 return ret;
633 }
634
635 if (!mute && !stream) {/* start playback */
636 ret = gb_audio_apbridgea_prepare_tx(data->connection,
637 0);
638 if (!ret)
639 ret = gb_audio_apbridgea_start_tx(data->connection,
640 0, 0);
641 params->state = GBAUDIO_CODEC_START;
642 } else if (!mute && stream) {/* start capture */
643 ret = gb_audio_apbridgea_prepare_rx(data->connection,
644 0);
645 if (!ret)
646 ret = gb_audio_apbridgea_start_rx(data->connection,
647 0);
648 params->state = GBAUDIO_CODEC_START;
649 } else if (mute && !stream) {/* stop playback */
650 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
651 if (!ret)
652 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
653 0);
654 params->state = GBAUDIO_CODEC_STOP;
655 } else if (mute && stream) {/* stop capture */
656 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
657 if (!ret)
658 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
659 0);
660 params->state = GBAUDIO_CODEC_STOP;
661 } else {
662 ret = -EINVAL;
663 }
664
665 if (ret)
666 dev_err_ratelimited(dai->dev,
667 "%s:Error during %s %s stream:%d\n",
668 module->name, mute ? "Mute" : "Unmute",
669 stream ? "Capture" : "Playback", ret);
670
671 gb_pm_runtime_put_noidle(bundle);
672 mutex_unlock(&codec->lock);
673 return ret;
674 }
675
676 static const struct snd_soc_dai_ops gbcodec_dai_ops = {
677 .startup = gbcodec_startup,
678 .shutdown = gbcodec_shutdown,
679 .hw_params = gbcodec_hw_params,
680 .prepare = gbcodec_prepare,
681 .mute_stream = gbcodec_mute_stream,
682 };
683
684 static struct snd_soc_dai_driver gbaudio_dai[] = {
685 {
686 .name = "apb-i2s0",
687 .id = 0,
688 .playback = {
689 .stream_name = "I2S 0 Playback",
690 .rates = SNDRV_PCM_RATE_48000,
691 .formats = SNDRV_PCM_FMTBIT_S16_LE,
692 .rate_max = 48000,
693 .rate_min = 48000,
694 .channels_min = 1,
695 .channels_max = 2,
696 .sig_bits = 16,
697 },
698 .capture = {
699 .stream_name = "I2S 0 Capture",
700 .rates = SNDRV_PCM_RATE_48000,
701 .formats = SNDRV_PCM_FMTBIT_S16_LE,
702 .rate_max = 48000,
703 .rate_min = 48000,
704 .channels_min = 1,
705 .channels_max = 2,
706 .sig_bits = 16,
707 },
708 .ops = &gbcodec_dai_ops,
709 },
710 };
711
gbaudio_init_jack(struct gbaudio_module_info * module,struct snd_soc_card * card)712 static int gbaudio_init_jack(struct gbaudio_module_info *module,
713 struct snd_soc_card *card)
714 {
715 int ret;
716 struct gbaudio_jack *jack, *n;
717 struct snd_soc_jack_pin *headset, *button;
718
719 if (!module->jack_mask)
720 return 0;
721
722 snprintf(module->jack_name, NAME_SIZE, "GB %d Headset Jack",
723 module->dev_id);
724
725 headset = devm_kzalloc(module->dev, sizeof(*headset), GFP_KERNEL);
726 if (!headset)
727 return -ENOMEM;
728
729 headset->pin = module->jack_name;
730 headset->mask = module->jack_mask;
731 ret = snd_soc_card_jack_new(card, module->jack_name, module->jack_mask,
732 &module->headset.jack, headset, 1);
733 if (ret) {
734 dev_err(module->dev, "Failed to create new jack\n");
735 return ret;
736 }
737
738 /* Add to module's jack list */
739 list_add(&module->headset.list, &module->jack_list);
740
741 if (!module->button_mask)
742 return 0;
743
744 snprintf(module->button_name, NAME_SIZE, "GB %d Button Jack",
745 module->dev_id);
746 button = devm_kzalloc(module->dev, sizeof(*button), GFP_KERNEL);
747 if (!button) {
748 ret = -ENOMEM;
749 goto free_jacks;
750 }
751
752 button->pin = module->button_name;
753 button->mask = module->button_mask;
754 ret = snd_soc_card_jack_new(card, module->button_name,
755 module->button_mask, &module->button.jack,
756 button, 1);
757 if (ret) {
758 dev_err(module->dev, "Failed to create button jack\n");
759 goto free_jacks;
760 }
761
762 /* Add to module's jack list */
763 list_add(&module->button.list, &module->jack_list);
764
765 /*
766 * Currently, max 4 buttons are supported with following key mapping
767 * BTN_0 = KEY_MEDIA
768 * BTN_1 = KEY_VOICECOMMAND
769 * BTN_2 = KEY_VOLUMEUP
770 * BTN_3 = KEY_VOLUMEDOWN
771 */
772
773 if (module->button_mask & SND_JACK_BTN_0) {
774 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_0,
775 KEY_MEDIA);
776 if (ret) {
777 dev_err(module->dev, "Failed to set BTN_0\n");
778 goto free_jacks;
779 }
780 }
781
782 if (module->button_mask & SND_JACK_BTN_1) {
783 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_1,
784 KEY_VOICECOMMAND);
785 if (ret) {
786 dev_err(module->dev, "Failed to set BTN_1\n");
787 goto free_jacks;
788 }
789 }
790
791 if (module->button_mask & SND_JACK_BTN_2) {
792 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_2,
793 KEY_VOLUMEUP);
794 if (ret) {
795 dev_err(module->dev, "Failed to set BTN_2\n");
796 goto free_jacks;
797 }
798 }
799
800 if (module->button_mask & SND_JACK_BTN_3) {
801 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_3,
802 KEY_VOLUMEDOWN);
803 if (ret) {
804 dev_err(module->dev, "Failed to set BTN_0\n");
805 goto free_jacks;
806 }
807 }
808
809 /* FIXME
810 * verify if this is really required
811 set_bit(INPUT_PROP_NO_DUMMY_RELEASE,
812 module->button.jack.jack->input_dev->propbit);
813 */
814
815 return 0;
816
817 free_jacks:
818 list_for_each_entry_safe(jack, n, &module->jack_list, list) {
819 snd_device_free(card->snd_card, jack->jack.jack);
820 list_del(&jack->list);
821 }
822
823 return ret;
824 }
825
gbaudio_register_module(struct gbaudio_module_info * module)826 int gbaudio_register_module(struct gbaudio_module_info *module)
827 {
828 int ret;
829 struct snd_soc_component *comp;
830 struct snd_card *card;
831 struct gbaudio_jack *jack = NULL;
832
833 if (!gbcodec) {
834 dev_err(module->dev, "GB Codec not yet probed\n");
835 return -EAGAIN;
836 }
837
838 comp = gbcodec->component;
839 card = comp->card->snd_card;
840
841 down_write(&card->controls_rwsem);
842
843 if (module->num_dais) {
844 dev_err(gbcodec->dev,
845 "%d:DAIs not supported via gbcodec driver\n",
846 module->num_dais);
847 up_write(&card->controls_rwsem);
848 return -EINVAL;
849 }
850
851 ret = gbaudio_init_jack(module, comp->card);
852 if (ret) {
853 up_write(&card->controls_rwsem);
854 return ret;
855 }
856
857 if (module->dapm_widgets)
858 snd_soc_dapm_new_controls(&comp->dapm, module->dapm_widgets,
859 module->num_dapm_widgets);
860 if (module->controls)
861 snd_soc_add_component_controls(comp, module->controls,
862 module->num_controls);
863 if (module->dapm_routes)
864 snd_soc_dapm_add_routes(&comp->dapm, module->dapm_routes,
865 module->num_dapm_routes);
866
867 /* card already instantiated, create widgets here only */
868 if (comp->card->instantiated) {
869 gbaudio_dapm_link_component_dai_widgets(comp->card,
870 &comp->dapm);
871 #ifdef CONFIG_SND_JACK
872 /*
873 * register jack devices for this module
874 * from codec->jack_list
875 */
876 list_for_each_entry(jack, &module->jack_list, list) {
877 snd_device_register(comp->card->snd_card,
878 jack->jack.jack);
879 }
880 #endif
881 }
882
883 mutex_lock(&gbcodec->lock);
884 list_add(&module->list, &gbcodec->module_list);
885 mutex_unlock(&gbcodec->lock);
886
887 if (comp->card->instantiated)
888 ret = snd_soc_dapm_new_widgets(comp->card);
889 dev_dbg(comp->dev, "Registered %s module\n", module->name);
890
891 up_write(&card->controls_rwsem);
892 return ret;
893 }
894 EXPORT_SYMBOL(gbaudio_register_module);
895
gbaudio_codec_clean_data_tx(struct gbaudio_data_connection * data)896 static void gbaudio_codec_clean_data_tx(struct gbaudio_data_connection *data)
897 {
898 u16 i2s_port, cportid;
899 int ret;
900
901 if (list_is_singular(&gbcodec->module_list)) {
902 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
903 if (ret)
904 return;
905 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
906 0);
907 if (ret)
908 return;
909 }
910 i2s_port = 0; /* fixed for now */
911 cportid = data->connection->hd_cport_id;
912 ret = gb_audio_apbridgea_unregister_cport(data->connection,
913 i2s_port, cportid,
914 AUDIO_APBRIDGEA_DIRECTION_TX);
915 data->state[0] = GBAUDIO_CODEC_SHUTDOWN;
916 }
917
gbaudio_codec_clean_data_rx(struct gbaudio_data_connection * data)918 static void gbaudio_codec_clean_data_rx(struct gbaudio_data_connection *data)
919 {
920 u16 i2s_port, cportid;
921 int ret;
922
923 if (list_is_singular(&gbcodec->module_list)) {
924 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
925 if (ret)
926 return;
927 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
928 0);
929 if (ret)
930 return;
931 }
932 i2s_port = 0; /* fixed for now */
933 cportid = data->connection->hd_cport_id;
934 ret = gb_audio_apbridgea_unregister_cport(data->connection,
935 i2s_port, cportid,
936 AUDIO_APBRIDGEA_DIRECTION_RX);
937 data->state[1] = GBAUDIO_CODEC_SHUTDOWN;
938 }
939
gbaudio_codec_cleanup(struct gbaudio_module_info * module)940 static void gbaudio_codec_cleanup(struct gbaudio_module_info *module)
941 {
942 struct gbaudio_data_connection *data;
943 int pb_state, cap_state;
944
945 dev_dbg(gbcodec->dev, "%s: removed, cleanup APBridge\n", module->name);
946 list_for_each_entry(data, &module->data_list, list) {
947 pb_state = data->state[0];
948 cap_state = data->state[1];
949
950 if (pb_state > GBAUDIO_CODEC_SHUTDOWN)
951 gbaudio_codec_clean_data_tx(data);
952
953 if (cap_state > GBAUDIO_CODEC_SHUTDOWN)
954 gbaudio_codec_clean_data_rx(data);
955 }
956 }
957
gbaudio_unregister_module(struct gbaudio_module_info * module)958 void gbaudio_unregister_module(struct gbaudio_module_info *module)
959 {
960 struct snd_soc_component *comp = gbcodec->component;
961 struct snd_card *card = comp->card->snd_card;
962 struct gbaudio_jack *jack, *n;
963 int mask;
964
965 dev_dbg(comp->dev, "Unregister %s module\n", module->name);
966
967 down_write(&card->controls_rwsem);
968 mutex_lock(&gbcodec->lock);
969 gbaudio_codec_cleanup(module);
970 list_del(&module->list);
971 dev_dbg(comp->dev, "Process Unregister %s module\n", module->name);
972 mutex_unlock(&gbcodec->lock);
973
974 #ifdef CONFIG_SND_JACK
975 /* free jack devices for this module jack_list */
976 list_for_each_entry_safe(jack, n, &module->jack_list, list) {
977 if (jack == &module->headset)
978 mask = GBCODEC_JACK_MASK;
979 else if (jack == &module->button)
980 mask = GBCODEC_JACK_BUTTON_MASK;
981 else
982 mask = 0;
983 if (mask) {
984 dev_dbg(module->dev, "Report %s removal\n",
985 jack->jack.jack->id);
986 snd_soc_jack_report(&jack->jack, 0, mask);
987 snd_device_free(comp->card->snd_card,
988 jack->jack.jack);
989 list_del(&jack->list);
990 }
991 }
992 #endif
993
994 if (module->dapm_routes) {
995 dev_dbg(comp->dev, "Removing %d routes\n",
996 module->num_dapm_routes);
997 snd_soc_dapm_del_routes(&comp->dapm, module->dapm_routes,
998 module->num_dapm_routes);
999 }
1000 if (module->controls) {
1001 dev_dbg(comp->dev, "Removing %d controls\n",
1002 module->num_controls);
1003 /* release control semaphore */
1004 up_write(&card->controls_rwsem);
1005 gbaudio_remove_component_controls(comp, module->controls,
1006 module->num_controls);
1007 down_write(&card->controls_rwsem);
1008 }
1009 if (module->dapm_widgets) {
1010 dev_dbg(comp->dev, "Removing %d widgets\n",
1011 module->num_dapm_widgets);
1012 gbaudio_dapm_free_controls(&comp->dapm, module->dapm_widgets,
1013 module->num_dapm_widgets);
1014 }
1015
1016 dev_dbg(comp->dev, "Unregistered %s module\n", module->name);
1017
1018 up_write(&card->controls_rwsem);
1019 }
1020 EXPORT_SYMBOL(gbaudio_unregister_module);
1021
1022 /*
1023 * component driver ops
1024 */
gbcodec_probe(struct snd_soc_component * comp)1025 static int gbcodec_probe(struct snd_soc_component *comp)
1026 {
1027 int i;
1028 struct gbaudio_codec_info *info;
1029 struct gbaudio_codec_dai *dai;
1030
1031 info = devm_kzalloc(comp->dev, sizeof(*info), GFP_KERNEL);
1032 if (!info)
1033 return -ENOMEM;
1034
1035 info->dev = comp->dev;
1036 INIT_LIST_HEAD(&info->module_list);
1037 mutex_init(&info->lock);
1038 INIT_LIST_HEAD(&info->dai_list);
1039
1040 /* init dai_list used to maintain runtime stream info */
1041 for (i = 0; i < ARRAY_SIZE(gbaudio_dai); i++) {
1042 dai = devm_kzalloc(comp->dev, sizeof(*dai), GFP_KERNEL);
1043 if (!dai)
1044 return -ENOMEM;
1045 dai->id = gbaudio_dai[i].id;
1046 list_add(&dai->list, &info->dai_list);
1047 }
1048
1049 info->component = comp;
1050 snd_soc_component_set_drvdata(comp, info);
1051 gbcodec = info;
1052
1053 device_init_wakeup(comp->dev, 1);
1054 return 0;
1055 }
1056
gbcodec_remove(struct snd_soc_component * comp)1057 static void gbcodec_remove(struct snd_soc_component *comp)
1058 {
1059 /* Empty function for now */
1060 return;
1061 }
1062
gbcodec_write(struct snd_soc_component * comp,unsigned int reg,unsigned int value)1063 static int gbcodec_write(struct snd_soc_component *comp, unsigned int reg,
1064 unsigned int value)
1065 {
1066 return 0;
1067 }
1068
gbcodec_read(struct snd_soc_component * comp,unsigned int reg)1069 static unsigned int gbcodec_read(struct snd_soc_component *comp,
1070 unsigned int reg)
1071 {
1072 return 0;
1073 }
1074
1075 static const struct snd_soc_component_driver soc_codec_dev_gbaudio = {
1076 .probe = gbcodec_probe,
1077 .remove = gbcodec_remove,
1078
1079 .read = gbcodec_read,
1080 .write = gbcodec_write,
1081 };
1082
1083 #ifdef CONFIG_PM
gbaudio_codec_suspend(struct device * dev)1084 static int gbaudio_codec_suspend(struct device *dev)
1085 {
1086 dev_dbg(dev, "%s: suspend\n", __func__);
1087 return 0;
1088 }
1089
gbaudio_codec_resume(struct device * dev)1090 static int gbaudio_codec_resume(struct device *dev)
1091 {
1092 dev_dbg(dev, "%s: resume\n", __func__);
1093 return 0;
1094 }
1095
1096 static const struct dev_pm_ops gbaudio_codec_pm_ops = {
1097 .suspend = gbaudio_codec_suspend,
1098 .resume = gbaudio_codec_resume,
1099 };
1100 #endif
1101
gbaudio_codec_probe(struct platform_device * pdev)1102 static int gbaudio_codec_probe(struct platform_device *pdev)
1103 {
1104 return devm_snd_soc_register_component(&pdev->dev,
1105 &soc_codec_dev_gbaudio,
1106 gbaudio_dai, ARRAY_SIZE(gbaudio_dai));
1107 }
1108
gbaudio_codec_remove(struct platform_device * pdev)1109 static int gbaudio_codec_remove(struct platform_device *pdev)
1110 {
1111 return 0;
1112 }
1113
1114 static const struct of_device_id greybus_asoc_machine_of_match[] = {
1115 { .compatible = "toshiba,apb-dummy-codec", },
1116 {},
1117 };
1118
1119 static struct platform_driver gbaudio_codec_driver = {
1120 .driver = {
1121 .name = "apb-dummy-codec",
1122 #ifdef CONFIG_PM
1123 .pm = &gbaudio_codec_pm_ops,
1124 #endif
1125 .of_match_table = greybus_asoc_machine_of_match,
1126 },
1127 .probe = gbaudio_codec_probe,
1128 .remove = gbaudio_codec_remove,
1129 };
1130 module_platform_driver(gbaudio_codec_driver);
1131
1132 MODULE_DESCRIPTION("APBridge ALSA SoC dummy codec driver");
1133 MODULE_AUTHOR("Vaibhav Agarwal <vaibhav.agarwal@linaro.org>");
1134 MODULE_LICENSE("GPL v2");
1135 MODULE_ALIAS("platform:apb-dummy-codec");
1136