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