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 gb_pm_runtime_put_noidle(bundle);
494 mutex_unlock(&codec->lock);
495 return ret;
496 }
497
498 gb_pm_runtime_put_noidle(bundle);
499
500 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
501 sig_bits = dai->driver->playback.sig_bits;
502 else
503 sig_bits = dai->driver->capture.sig_bits;
504
505 params->state = GBAUDIO_CODEC_HWPARAMS;
506 params->format = format;
507 params->rate = rate;
508 params->channels = channels;
509 params->sig_bits = sig_bits;
510
511 mutex_unlock(&codec->lock);
512 return 0;
513 }
514
gbcodec_prepare(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)515 static int gbcodec_prepare(struct snd_pcm_substream *substream,
516 struct snd_soc_dai *dai)
517 {
518 int ret;
519 struct gbaudio_module_info *module;
520 struct gbaudio_data_connection *data;
521 struct gb_bundle *bundle;
522 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
523 struct gbaudio_stream_params *params;
524
525 mutex_lock(&codec->lock);
526
527 if (list_empty(&codec->module_list)) {
528 dev_err(codec->dev, "No codec module available\n");
529 mutex_unlock(&codec->lock);
530 return -ENODEV;
531 }
532
533 list_for_each_entry(module, &codec->module_list, list) {
534 /* find the dai */
535 data = find_data(module, dai->id);
536 if (data)
537 break;
538 }
539 if (!data) {
540 dev_err(dai->dev, "DATA connection missing\n");
541 mutex_unlock(&codec->lock);
542 return -ENODEV;
543 }
544
545 params = find_dai_stream_params(codec, dai->id, substream->stream);
546 if (!params) {
547 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
548 mutex_unlock(&codec->lock);
549 return -EINVAL;
550 }
551
552 bundle = to_gb_bundle(module->dev);
553 ret = gb_pm_runtime_get_sync(bundle);
554 if (ret) {
555 mutex_unlock(&codec->lock);
556 return ret;
557 }
558
559 switch (substream->stream) {
560 case SNDRV_PCM_STREAM_PLAYBACK:
561 ret = gb_audio_apbridgea_set_tx_data_size(data->connection, 0,
562 192);
563 break;
564 case SNDRV_PCM_STREAM_CAPTURE:
565 ret = gb_audio_apbridgea_set_rx_data_size(data->connection, 0,
566 192);
567 break;
568 }
569 if (ret) {
570 gb_pm_runtime_put_noidle(bundle);
571 mutex_unlock(&codec->lock);
572 dev_err_ratelimited(dai->dev, "set_data_size failed:%d\n",
573 ret);
574 return ret;
575 }
576
577 gb_pm_runtime_put_noidle(bundle);
578
579 params->state = GBAUDIO_CODEC_PREPARE;
580 mutex_unlock(&codec->lock);
581 return 0;
582 }
583
gbcodec_mute_stream(struct snd_soc_dai * dai,int mute,int stream)584 static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
585 {
586 int ret;
587 struct gbaudio_data_connection *data;
588 struct gbaudio_module_info *module;
589 struct gb_bundle *bundle;
590 struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
591 struct gbaudio_stream_params *params;
592
593 dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
594 stream ? "CAPTURE" : "PLAYBACK");
595
596 mutex_lock(&codec->lock);
597
598 params = find_dai_stream_params(codec, dai->id, stream);
599 if (!params) {
600 dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
601 mutex_unlock(&codec->lock);
602 return -EINVAL;
603 }
604
605 if (list_empty(&codec->module_list)) {
606 dev_err(codec->dev, "No codec module available\n");
607 if (mute) {
608 params->state = GBAUDIO_CODEC_STOP;
609 ret = 0;
610 } else {
611 ret = -ENODEV;
612 }
613 mutex_unlock(&codec->lock);
614 return ret;
615 }
616
617 list_for_each_entry(module, &codec->module_list, list) {
618 /* find the dai */
619 data = find_data(module, dai->id);
620 if (data)
621 break;
622 }
623 if (!data) {
624 dev_err(dai->dev, "%s:%s DATA connection missing\n",
625 dai->name, module->name);
626 mutex_unlock(&codec->lock);
627 return -ENODEV;
628 }
629
630 bundle = to_gb_bundle(module->dev);
631 ret = gb_pm_runtime_get_sync(bundle);
632 if (ret) {
633 mutex_unlock(&codec->lock);
634 return ret;
635 }
636
637 if (!mute && !stream) {/* start playback */
638 ret = gb_audio_apbridgea_prepare_tx(data->connection,
639 0);
640 if (!ret)
641 ret = gb_audio_apbridgea_start_tx(data->connection,
642 0, 0);
643 params->state = GBAUDIO_CODEC_START;
644 } else if (!mute && stream) {/* start capture */
645 ret = gb_audio_apbridgea_prepare_rx(data->connection,
646 0);
647 if (!ret)
648 ret = gb_audio_apbridgea_start_rx(data->connection,
649 0);
650 params->state = GBAUDIO_CODEC_START;
651 } else if (mute && !stream) {/* stop playback */
652 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
653 if (!ret)
654 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
655 0);
656 params->state = GBAUDIO_CODEC_STOP;
657 } else if (mute && stream) {/* stop capture */
658 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
659 if (!ret)
660 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
661 0);
662 params->state = GBAUDIO_CODEC_STOP;
663 } else {
664 ret = -EINVAL;
665 }
666
667 if (ret)
668 dev_err_ratelimited(dai->dev,
669 "%s:Error during %s %s stream:%d\n",
670 module->name, mute ? "Mute" : "Unmute",
671 stream ? "Capture" : "Playback", ret);
672
673 gb_pm_runtime_put_noidle(bundle);
674 mutex_unlock(&codec->lock);
675 return ret;
676 }
677
678 static const struct snd_soc_dai_ops gbcodec_dai_ops = {
679 .startup = gbcodec_startup,
680 .shutdown = gbcodec_shutdown,
681 .hw_params = gbcodec_hw_params,
682 .prepare = gbcodec_prepare,
683 .mute_stream = gbcodec_mute_stream,
684 };
685
686 static struct snd_soc_dai_driver gbaudio_dai[] = {
687 {
688 .name = "apb-i2s0",
689 .id = 0,
690 .playback = {
691 .stream_name = "I2S 0 Playback",
692 .rates = SNDRV_PCM_RATE_48000,
693 .formats = SNDRV_PCM_FMTBIT_S16_LE,
694 .rate_max = 48000,
695 .rate_min = 48000,
696 .channels_min = 1,
697 .channels_max = 2,
698 .sig_bits = 16,
699 },
700 .capture = {
701 .stream_name = "I2S 0 Capture",
702 .rates = SNDRV_PCM_RATE_48000,
703 .formats = SNDRV_PCM_FMTBIT_S16_LE,
704 .rate_max = 48000,
705 .rate_min = 48000,
706 .channels_min = 1,
707 .channels_max = 2,
708 .sig_bits = 16,
709 },
710 .ops = &gbcodec_dai_ops,
711 },
712 };
713
gbaudio_init_jack(struct gbaudio_module_info * module,struct snd_soc_card * card)714 static int gbaudio_init_jack(struct gbaudio_module_info *module,
715 struct snd_soc_card *card)
716 {
717 int ret;
718 struct gbaudio_jack *jack, *n;
719 struct snd_soc_jack_pin *headset, *button;
720
721 if (!module->jack_mask)
722 return 0;
723
724 snprintf(module->jack_name, NAME_SIZE, "GB %d Headset Jack",
725 module->dev_id);
726
727 headset = devm_kzalloc(module->dev, sizeof(*headset), GFP_KERNEL);
728 if (!headset)
729 return -ENOMEM;
730
731 headset->pin = module->jack_name;
732 headset->mask = module->jack_mask;
733 ret = snd_soc_card_jack_new(card, module->jack_name, module->jack_mask,
734 &module->headset.jack, headset, 1);
735 if (ret) {
736 dev_err(module->dev, "Failed to create new jack\n");
737 return ret;
738 }
739
740 /* Add to module's jack list */
741 list_add(&module->headset.list, &module->jack_list);
742
743 if (!module->button_mask)
744 return 0;
745
746 snprintf(module->button_name, NAME_SIZE, "GB %d Button Jack",
747 module->dev_id);
748 button = devm_kzalloc(module->dev, sizeof(*button), GFP_KERNEL);
749 if (!button) {
750 ret = -ENOMEM;
751 goto free_jacks;
752 }
753
754 button->pin = module->button_name;
755 button->mask = module->button_mask;
756 ret = snd_soc_card_jack_new(card, module->button_name,
757 module->button_mask, &module->button.jack,
758 button, 1);
759 if (ret) {
760 dev_err(module->dev, "Failed to create button jack\n");
761 goto free_jacks;
762 }
763
764 /* Add to module's jack list */
765 list_add(&module->button.list, &module->jack_list);
766
767 /*
768 * Currently, max 4 buttons are supported with following key mapping
769 * BTN_0 = KEY_MEDIA
770 * BTN_1 = KEY_VOICECOMMAND
771 * BTN_2 = KEY_VOLUMEUP
772 * BTN_3 = KEY_VOLUMEDOWN
773 */
774
775 if (module->button_mask & SND_JACK_BTN_0) {
776 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_0,
777 KEY_MEDIA);
778 if (ret) {
779 dev_err(module->dev, "Failed to set BTN_0\n");
780 goto free_jacks;
781 }
782 }
783
784 if (module->button_mask & SND_JACK_BTN_1) {
785 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_1,
786 KEY_VOICECOMMAND);
787 if (ret) {
788 dev_err(module->dev, "Failed to set BTN_1\n");
789 goto free_jacks;
790 }
791 }
792
793 if (module->button_mask & SND_JACK_BTN_2) {
794 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_2,
795 KEY_VOLUMEUP);
796 if (ret) {
797 dev_err(module->dev, "Failed to set BTN_2\n");
798 goto free_jacks;
799 }
800 }
801
802 if (module->button_mask & SND_JACK_BTN_3) {
803 ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_3,
804 KEY_VOLUMEDOWN);
805 if (ret) {
806 dev_err(module->dev, "Failed to set BTN_0\n");
807 goto free_jacks;
808 }
809 }
810
811 /* FIXME
812 * verify if this is really required
813 set_bit(INPUT_PROP_NO_DUMMY_RELEASE,
814 module->button.jack.jack->input_dev->propbit);
815 */
816
817 return 0;
818
819 free_jacks:
820 list_for_each_entry_safe(jack, n, &module->jack_list, list) {
821 snd_device_free(card->snd_card, jack->jack.jack);
822 list_del(&jack->list);
823 }
824
825 return ret;
826 }
827
gbaudio_register_module(struct gbaudio_module_info * module)828 int gbaudio_register_module(struct gbaudio_module_info *module)
829 {
830 int ret;
831 struct snd_soc_component *comp;
832 struct snd_card *card;
833 struct gbaudio_jack *jack = NULL;
834
835 if (!gbcodec) {
836 dev_err(module->dev, "GB Codec not yet probed\n");
837 return -EAGAIN;
838 }
839
840 comp = gbcodec->component;
841 card = comp->card->snd_card;
842
843 down_write(&card->controls_rwsem);
844
845 if (module->num_dais) {
846 dev_err(gbcodec->dev,
847 "%d:DAIs not supported via gbcodec driver\n",
848 module->num_dais);
849 up_write(&card->controls_rwsem);
850 return -EINVAL;
851 }
852
853 ret = gbaudio_init_jack(module, comp->card);
854 if (ret) {
855 up_write(&card->controls_rwsem);
856 return ret;
857 }
858
859 if (module->dapm_widgets)
860 snd_soc_dapm_new_controls(&comp->dapm, module->dapm_widgets,
861 module->num_dapm_widgets);
862 if (module->controls)
863 snd_soc_add_component_controls(comp, module->controls,
864 module->num_controls);
865 if (module->dapm_routes)
866 snd_soc_dapm_add_routes(&comp->dapm, module->dapm_routes,
867 module->num_dapm_routes);
868
869 /* card already instantiated, create widgets here only */
870 if (comp->card->instantiated) {
871 gbaudio_dapm_link_component_dai_widgets(comp->card,
872 &comp->dapm);
873 #ifdef CONFIG_SND_JACK
874 /*
875 * register jack devices for this module
876 * from codec->jack_list
877 */
878 list_for_each_entry(jack, &module->jack_list, list) {
879 snd_device_register(comp->card->snd_card,
880 jack->jack.jack);
881 }
882 #endif
883 }
884
885 mutex_lock(&gbcodec->lock);
886 list_add(&module->list, &gbcodec->module_list);
887 mutex_unlock(&gbcodec->lock);
888
889 if (comp->card->instantiated)
890 ret = snd_soc_dapm_new_widgets(comp->card);
891 dev_dbg(comp->dev, "Registered %s module\n", module->name);
892
893 up_write(&card->controls_rwsem);
894 return ret;
895 }
896 EXPORT_SYMBOL(gbaudio_register_module);
897
gbaudio_codec_clean_data_tx(struct gbaudio_data_connection * data)898 static void gbaudio_codec_clean_data_tx(struct gbaudio_data_connection *data)
899 {
900 u16 i2s_port, cportid;
901 int ret;
902
903 if (list_is_singular(&gbcodec->module_list)) {
904 ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
905 if (ret)
906 return;
907 ret = gb_audio_apbridgea_shutdown_tx(data->connection,
908 0);
909 if (ret)
910 return;
911 }
912 i2s_port = 0; /* fixed for now */
913 cportid = data->connection->hd_cport_id;
914 ret = gb_audio_apbridgea_unregister_cport(data->connection,
915 i2s_port, cportid,
916 AUDIO_APBRIDGEA_DIRECTION_TX);
917 data->state[0] = GBAUDIO_CODEC_SHUTDOWN;
918 }
919
gbaudio_codec_clean_data_rx(struct gbaudio_data_connection * data)920 static void gbaudio_codec_clean_data_rx(struct gbaudio_data_connection *data)
921 {
922 u16 i2s_port, cportid;
923 int ret;
924
925 if (list_is_singular(&gbcodec->module_list)) {
926 ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
927 if (ret)
928 return;
929 ret = gb_audio_apbridgea_shutdown_rx(data->connection,
930 0);
931 if (ret)
932 return;
933 }
934 i2s_port = 0; /* fixed for now */
935 cportid = data->connection->hd_cport_id;
936 ret = gb_audio_apbridgea_unregister_cport(data->connection,
937 i2s_port, cportid,
938 AUDIO_APBRIDGEA_DIRECTION_RX);
939 data->state[1] = GBAUDIO_CODEC_SHUTDOWN;
940 }
941
gbaudio_codec_cleanup(struct gbaudio_module_info * module)942 static void gbaudio_codec_cleanup(struct gbaudio_module_info *module)
943 {
944 struct gbaudio_data_connection *data;
945 int pb_state, cap_state;
946
947 dev_dbg(gbcodec->dev, "%s: removed, cleanup APBridge\n", module->name);
948 list_for_each_entry(data, &module->data_list, list) {
949 pb_state = data->state[0];
950 cap_state = data->state[1];
951
952 if (pb_state > GBAUDIO_CODEC_SHUTDOWN)
953 gbaudio_codec_clean_data_tx(data);
954
955 if (cap_state > GBAUDIO_CODEC_SHUTDOWN)
956 gbaudio_codec_clean_data_rx(data);
957 }
958 }
959
gbaudio_unregister_module(struct gbaudio_module_info * module)960 void gbaudio_unregister_module(struct gbaudio_module_info *module)
961 {
962 struct snd_soc_component *comp = gbcodec->component;
963 struct snd_card *card = comp->card->snd_card;
964 struct gbaudio_jack *jack, *n;
965 int mask;
966
967 dev_dbg(comp->dev, "Unregister %s module\n", module->name);
968
969 down_write(&card->controls_rwsem);
970 mutex_lock(&gbcodec->lock);
971 gbaudio_codec_cleanup(module);
972 list_del(&module->list);
973 dev_dbg(comp->dev, "Process Unregister %s module\n", module->name);
974 mutex_unlock(&gbcodec->lock);
975
976 #ifdef CONFIG_SND_JACK
977 /* free jack devices for this module jack_list */
978 list_for_each_entry_safe(jack, n, &module->jack_list, list) {
979 if (jack == &module->headset)
980 mask = GBCODEC_JACK_MASK;
981 else if (jack == &module->button)
982 mask = GBCODEC_JACK_BUTTON_MASK;
983 else
984 mask = 0;
985 if (mask) {
986 dev_dbg(module->dev, "Report %s removal\n",
987 jack->jack.jack->id);
988 snd_soc_jack_report(&jack->jack, 0, mask);
989 snd_device_free(comp->card->snd_card,
990 jack->jack.jack);
991 list_del(&jack->list);
992 }
993 }
994 #endif
995
996 if (module->dapm_routes) {
997 dev_dbg(comp->dev, "Removing %d routes\n",
998 module->num_dapm_routes);
999 snd_soc_dapm_del_routes(&comp->dapm, module->dapm_routes,
1000 module->num_dapm_routes);
1001 }
1002 if (module->controls) {
1003 dev_dbg(comp->dev, "Removing %d controls\n",
1004 module->num_controls);
1005 /* release control semaphore */
1006 up_write(&card->controls_rwsem);
1007 gbaudio_remove_component_controls(comp, module->controls,
1008 module->num_controls);
1009 down_write(&card->controls_rwsem);
1010 }
1011 if (module->dapm_widgets) {
1012 dev_dbg(comp->dev, "Removing %d widgets\n",
1013 module->num_dapm_widgets);
1014 gbaudio_dapm_free_controls(&comp->dapm, module->dapm_widgets,
1015 module->num_dapm_widgets);
1016 }
1017
1018 dev_dbg(comp->dev, "Unregistered %s module\n", module->name);
1019
1020 up_write(&card->controls_rwsem);
1021 }
1022 EXPORT_SYMBOL(gbaudio_unregister_module);
1023
1024 /*
1025 * component driver ops
1026 */
gbcodec_probe(struct snd_soc_component * comp)1027 static int gbcodec_probe(struct snd_soc_component *comp)
1028 {
1029 int i;
1030 struct gbaudio_codec_info *info;
1031 struct gbaudio_codec_dai *dai;
1032
1033 info = devm_kzalloc(comp->dev, sizeof(*info), GFP_KERNEL);
1034 if (!info)
1035 return -ENOMEM;
1036
1037 info->dev = comp->dev;
1038 INIT_LIST_HEAD(&info->module_list);
1039 mutex_init(&info->lock);
1040 INIT_LIST_HEAD(&info->dai_list);
1041
1042 /* init dai_list used to maintain runtime stream info */
1043 for (i = 0; i < ARRAY_SIZE(gbaudio_dai); i++) {
1044 dai = devm_kzalloc(comp->dev, sizeof(*dai), GFP_KERNEL);
1045 if (!dai)
1046 return -ENOMEM;
1047 dai->id = gbaudio_dai[i].id;
1048 list_add(&dai->list, &info->dai_list);
1049 }
1050
1051 info->component = comp;
1052 snd_soc_component_set_drvdata(comp, info);
1053 gbcodec = info;
1054
1055 device_init_wakeup(comp->dev, 1);
1056 return 0;
1057 }
1058
gbcodec_remove(struct snd_soc_component * comp)1059 static void gbcodec_remove(struct snd_soc_component *comp)
1060 {
1061 /* Empty function for now */
1062 return;
1063 }
1064
gbcodec_write(struct snd_soc_component * comp,unsigned int reg,unsigned int value)1065 static int gbcodec_write(struct snd_soc_component *comp, unsigned int reg,
1066 unsigned int value)
1067 {
1068 return 0;
1069 }
1070
gbcodec_read(struct snd_soc_component * comp,unsigned int reg)1071 static unsigned int gbcodec_read(struct snd_soc_component *comp,
1072 unsigned int reg)
1073 {
1074 return 0;
1075 }
1076
1077 static const struct snd_soc_component_driver soc_codec_dev_gbaudio = {
1078 .probe = gbcodec_probe,
1079 .remove = gbcodec_remove,
1080
1081 .read = gbcodec_read,
1082 .write = gbcodec_write,
1083 };
1084
1085 #ifdef CONFIG_PM
gbaudio_codec_suspend(struct device * dev)1086 static int gbaudio_codec_suspend(struct device *dev)
1087 {
1088 dev_dbg(dev, "%s: suspend\n", __func__);
1089 return 0;
1090 }
1091
gbaudio_codec_resume(struct device * dev)1092 static int gbaudio_codec_resume(struct device *dev)
1093 {
1094 dev_dbg(dev, "%s: resume\n", __func__);
1095 return 0;
1096 }
1097
1098 static const struct dev_pm_ops gbaudio_codec_pm_ops = {
1099 .suspend = gbaudio_codec_suspend,
1100 .resume = gbaudio_codec_resume,
1101 };
1102 #endif
1103
gbaudio_codec_probe(struct platform_device * pdev)1104 static int gbaudio_codec_probe(struct platform_device *pdev)
1105 {
1106 return devm_snd_soc_register_component(&pdev->dev,
1107 &soc_codec_dev_gbaudio,
1108 gbaudio_dai, ARRAY_SIZE(gbaudio_dai));
1109 }
1110
gbaudio_codec_remove(struct platform_device * pdev)1111 static int gbaudio_codec_remove(struct platform_device *pdev)
1112 {
1113 return 0;
1114 }
1115
1116 static const struct of_device_id greybus_asoc_machine_of_match[] = {
1117 { .compatible = "toshiba,apb-dummy-codec", },
1118 {},
1119 };
1120
1121 static struct platform_driver gbaudio_codec_driver = {
1122 .driver = {
1123 .name = "apb-dummy-codec",
1124 #ifdef CONFIG_PM
1125 .pm = &gbaudio_codec_pm_ops,
1126 #endif
1127 .of_match_table = greybus_asoc_machine_of_match,
1128 },
1129 .probe = gbaudio_codec_probe,
1130 .remove = gbaudio_codec_remove,
1131 };
1132 module_platform_driver(gbaudio_codec_driver);
1133
1134 MODULE_DESCRIPTION("APBridge ALSA SoC dummy codec driver");
1135 MODULE_AUTHOR("Vaibhav Agarwal <vaibhav.agarwal@linaro.org>");
1136 MODULE_LICENSE("GPL v2");
1137 MODULE_ALIAS("platform:apb-dummy-codec");
1138