3 * Copyright 2015-2016 Google Inc.
4 * Copyright 2015-2016 Linaro Ltd.
6 * Released under the GPLv2 only.
9 #include "audio_codec.h"
10 #include "greybus_protocols.h"
12 #define GBAUDIO_INVALID_ID 0xFF
15 struct gb_mixer_control {
17 unsigned int reg, rreg, shift, rshift, invert;
20 struct gbaudio_ctl_pvt {
22 unsigned int data_cport;
25 struct gb_audio_ctl_elem_info *info;
28 static const char *gbaudio_map_controlid(struct gbaudio_codec_info *gbcodec,
29 __u8 control_id, __u8 index)
31 struct gbaudio_control *control;
33 if (control_id == GBAUDIO_INVALID_ID)
36 list_for_each_entry(control, &gbcodec->codec_ctl_list, list) {
37 if (control->id == control_id) {
38 if (index == GBAUDIO_INVALID_ID)
40 return control->texts[index];
43 list_for_each_entry(control, &gbcodec->widget_ctl_list, list) {
44 if (control->id == control_id) {
45 if (index == GBAUDIO_INVALID_ID)
47 return control->texts[index];
53 static int gbaudio_map_widgetname(struct gbaudio_codec_info *gbcodec,
56 struct gbaudio_widget *widget;
57 char widget_name[NAME_SIZE];
58 char prefix_name[NAME_SIZE];
60 snprintf(prefix_name, NAME_SIZE, "GB %d ", gbcodec->dev_id);
61 if (strncmp(name, prefix_name, strlen(prefix_name)))
64 strlcpy(widget_name, name+strlen(prefix_name), NAME_SIZE);
65 dev_dbg(gbcodec->dev, "widget_name:%s, truncated widget_name:%s\n",
68 list_for_each_entry(widget, &gbcodec->widget_list, list) {
69 if (!strncmp(widget->name, widget_name, NAME_SIZE))
75 static const char *gbaudio_map_widgetid(struct gbaudio_codec_info *gbcodec,
78 struct gbaudio_widget *widget;
80 list_for_each_entry(widget, &gbcodec->widget_list, list) {
81 if (widget->id == widget_id)
87 static int gbcodec_mixer_ctl_info(struct snd_kcontrol *kcontrol,
88 struct snd_ctl_elem_info *uinfo)
92 struct gbaudio_ctl_pvt *data;
93 struct gb_audio_ctl_elem_info *info;
94 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
95 struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
96 struct gbaudio_codec_info *gbcodec = audio->gbcodec;
98 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
99 info = (struct gb_audio_ctl_elem_info *)data->info;
102 dev_err(gbcodec->dev, "NULL info for %s\n", uinfo->id.name);
107 uinfo->access = data->access;
108 uinfo->count = data->vcount;
109 uinfo->type = (snd_ctl_elem_type_t)info->type;
111 switch (info->type) {
112 case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
113 case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
114 uinfo->value.integer.min = info->value.integer.min;
115 uinfo->value.integer.max = info->value.integer.max;
117 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
118 max = info->value.enumerated.items;
119 uinfo->value.enumerated.items = max;
120 if (uinfo->value.enumerated.item > max - 1)
121 uinfo->value.enumerated.item = max - 1;
122 name = gbaudio_map_controlid(gbcodec, data->ctl_id,
123 uinfo->value.enumerated.item);
124 strlcpy(uinfo->value.enumerated.name, name, NAME_SIZE);
127 dev_err(codec->dev, "Invalid type: %d for %s:kcontrol\n",
128 info->type, kcontrol->id.name);
134 static int gbcodec_mixer_ctl_get(struct snd_kcontrol *kcontrol,
135 struct snd_ctl_elem_value *ucontrol)
138 struct gb_audio_ctl_elem_info *info;
139 struct gbaudio_ctl_pvt *data;
140 struct gb_audio_ctl_elem_value gbvalue;
141 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
142 struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
143 struct gbaudio_codec_info *gb = audio->gbcodec;
145 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
146 info = (struct gb_audio_ctl_elem_info *)data->info;
148 ret = gb_audio_gb_get_control(gb->mgmt_connection, data->ctl_id,
149 GB_AUDIO_INVALID_INDEX, &gbvalue);
151 dev_err(codec->dev, "%d:Error in %s for %s\n", ret, __func__,
156 /* update ucontrol */
157 switch (info->type) {
158 case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
159 case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
160 ucontrol->value.integer.value[0] =
161 gbvalue.value.integer_value[0];
162 if (data->vcount == 2)
163 ucontrol->value.integer.value[1] =
164 gbvalue.value.integer_value[1];
166 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
167 ucontrol->value.enumerated.item[0] =
168 gbvalue.value.enumerated_item[0];
169 if (data->vcount == 2)
170 ucontrol->value.enumerated.item[1] =
171 gbvalue.value.enumerated_item[1];
174 dev_err(codec->dev, "Invalid type: %d for %s:kcontrol\n",
175 info->type, kcontrol->id.name);
182 static int gbcodec_mixer_ctl_put(struct snd_kcontrol *kcontrol,
183 struct snd_ctl_elem_value *ucontrol)
186 struct gb_audio_ctl_elem_info *info;
187 struct gbaudio_ctl_pvt *data;
188 struct gb_audio_ctl_elem_value gbvalue;
189 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
190 struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
191 struct gbaudio_codec_info *gb = audio->gbcodec;
193 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
194 info = (struct gb_audio_ctl_elem_info *)data->info;
196 /* update ucontrol */
197 switch (info->type) {
198 case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
199 case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
200 gbvalue.value.integer_value[0] =
201 ucontrol->value.integer.value[0];
202 if (data->vcount == 2)
203 gbvalue.value.integer_value[1] =
204 ucontrol->value.integer.value[1];
206 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
207 gbvalue.value.enumerated_item[0] =
208 ucontrol->value.enumerated.item[0];
209 if (data->vcount == 2)
210 gbvalue.value.enumerated_item[1] =
211 ucontrol->value.enumerated.item[1];
214 dev_err(codec->dev, "Invalid type: %d for %s:kcontrol\n",
215 info->type, kcontrol->id.name);
223 ret = gb_audio_gb_set_control(gb->mgmt_connection, data->ctl_id,
224 GB_AUDIO_INVALID_INDEX, &gbvalue);
226 dev_err(codec->dev, "%d:Error in %s for %s\n", ret, __func__,
233 #define SOC_MIXER_GB(xname, kcount, data) \
234 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
235 .count = kcount, .info = gbcodec_mixer_ctl_info, \
236 .get = gbcodec_mixer_ctl_get, .put = gbcodec_mixer_ctl_put, \
237 .private_value = (unsigned long)data }
240 * although below callback functions seems redundant to above functions.
241 * same are kept to allow provision for different handling in case
242 * of DAPM related sequencing, etc.
244 static int gbcodec_mixer_dapm_ctl_info(struct snd_kcontrol *kcontrol,
245 struct snd_ctl_elem_info *uinfo)
247 int platform_max, platform_min;
248 struct gbaudio_ctl_pvt *data;
249 struct gb_audio_ctl_elem_info *info;
251 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
252 info = (struct gb_audio_ctl_elem_info *)data->info;
255 platform_max = info->value.integer.max;
256 platform_min = info->value.integer.min;
258 if (platform_max == 1 &&
259 !strnstr(kcontrol->id.name, " Volume", NAME_SIZE))
260 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
262 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
264 uinfo->count = data->vcount;
265 uinfo->value.integer.min = 0;
266 if (info->value.integer.min < 0 &&
267 (uinfo->type == SNDRV_CTL_ELEM_TYPE_INTEGER))
268 uinfo->value.integer.max = platform_max - platform_min;
270 uinfo->value.integer.max = platform_max;
275 static int gbcodec_mixer_dapm_ctl_get(struct snd_kcontrol *kcontrol,
276 struct snd_ctl_elem_value *ucontrol)
279 struct gb_audio_ctl_elem_info *info;
280 struct gbaudio_ctl_pvt *data;
281 struct gb_audio_ctl_elem_value gbvalue;
282 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
283 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
284 struct snd_soc_codec *codec = widget->codec;
285 struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
286 struct gbaudio_codec_info *gb = audio->gbcodec;
288 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
289 info = (struct gb_audio_ctl_elem_info *)data->info;
291 if (data->vcount == 2)
292 dev_warn(widget->dapm->dev,
293 "GB: Control '%s' is stereo, which is not supported\n",
296 ret = gb_audio_gb_get_control(gb->mgmt_connection, data->ctl_id,
297 GB_AUDIO_INVALID_INDEX, &gbvalue);
299 dev_err(codec->dev, "%d:Error in %s for %s\n", ret, __func__,
303 /* update ucontrol */
304 ucontrol->value.integer.value[0] = gbvalue.value.integer_value[0];
309 static int gbcodec_mixer_dapm_ctl_put(struct snd_kcontrol *kcontrol,
310 struct snd_ctl_elem_value *ucontrol)
312 int ret, wi, max, connect;
313 unsigned int mask, val;
314 struct gb_audio_ctl_elem_info *info;
315 struct gbaudio_ctl_pvt *data;
316 struct gb_audio_ctl_elem_value gbvalue;
317 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
318 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
319 struct snd_soc_codec *codec = widget->codec;
320 struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
321 struct gbaudio_codec_info *gb = audio->gbcodec;
323 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
324 info = (struct gb_audio_ctl_elem_info *)data->info;
326 if (data->vcount == 2)
327 dev_warn(widget->dapm->dev,
328 "GB: Control '%s' is stereo, which is not supported\n",
331 max = info->value.integer.max;
332 mask = (1 << fls(max)) - 1;
333 val = (ucontrol->value.integer.value[0] & mask);
336 /* update ucontrol */
337 if (gbvalue.value.integer_value[0] != val) {
338 for (wi = 0; wi < wlist->num_widgets; wi++) {
339 widget = wlist->widgets[wi];
342 widget->dapm->update = NULL;
343 snd_soc_dapm_mixer_update_power(widget, kcontrol,
346 gbvalue.value.integer_value[0] =
347 ucontrol->value.integer.value[0];
348 ret = gb_audio_gb_set_control(gb->mgmt_connection,
350 GB_AUDIO_INVALID_INDEX, &gbvalue);
353 "%d:Error in %s for %s\n", ret, __func__,
361 #define SOC_DAPM_MIXER_GB(xname, kcount, data) \
362 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
363 .count = kcount, .info = gbcodec_mixer_dapm_ctl_info, \
364 .get = gbcodec_mixer_dapm_ctl_get, .put = gbcodec_mixer_dapm_ctl_put, \
365 .private_value = (unsigned long)data}
367 static int gbcodec_event_spk(struct snd_soc_dapm_widget *w,
368 struct snd_kcontrol *k, int event)
370 /* Ensure GB speaker is connected */
375 static int gbcodec_event_hp(struct snd_soc_dapm_widget *w,
376 struct snd_kcontrol *k, int event)
378 /* Ensure GB module supports jack slot */
383 static int gbcodec_event_int_mic(struct snd_soc_dapm_widget *w,
384 struct snd_kcontrol *k, int event)
386 /* Ensure GB module supports jack slot */
391 static int gbaudio_validate_kcontrol_count(struct gb_audio_widget *w)
396 case snd_soc_dapm_spk:
397 case snd_soc_dapm_hp:
398 case snd_soc_dapm_mic:
399 case snd_soc_dapm_output:
400 case snd_soc_dapm_input:
404 case snd_soc_dapm_switch:
405 case snd_soc_dapm_mux:
406 if (w->ncontrols != 1)
416 static int gbaudio_tplg_create_kcontrol(struct gbaudio_codec_info *gb,
417 struct snd_kcontrol_new *kctl,
418 struct gb_audio_control *ctl)
420 struct gbaudio_ctl_pvt *ctldata;
422 switch (ctl->iface) {
423 case SNDRV_CTL_ELEM_IFACE_MIXER:
424 ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),
428 ctldata->ctl_id = ctl->id;
429 ctldata->data_cport = ctl->data_cport;
430 ctldata->access = ctl->access;
431 ctldata->vcount = ctl->count_values;
432 ctldata->info = &ctl->info;
433 *kctl = (struct snd_kcontrol_new)
434 SOC_MIXER_GB(ctl->name, ctl->count, ctldata);
441 dev_dbg(gb->dev, "%s:%d control created\n", ctl->name, ctl->id);
445 static const char * const gbtexts[] = {"Stereo", "Left", "Right"};
447 static const SOC_ENUM_SINGLE_DECL(
448 gbcodec_apb1_rx_enum, GBCODEC_APB1_MUX_REG, 0, gbtexts);
450 static const SOC_ENUM_SINGLE_DECL(
451 gbcodec_mic_enum, GBCODEC_APB1_MUX_REG, 4, gbtexts);
453 static int gbaudio_tplg_create_enum_ctl(struct gbaudio_codec_info *gb,
454 struct snd_kcontrol_new *kctl,
455 struct gb_audio_control *ctl)
459 *kctl = (struct snd_kcontrol_new)
460 SOC_DAPM_ENUM(ctl->name, gbcodec_apb1_rx_enum);
463 *kctl = (struct snd_kcontrol_new)
464 SOC_DAPM_ENUM(ctl->name, gbcodec_mic_enum);
473 static int gbaudio_tplg_create_mixer_ctl(struct gbaudio_codec_info *gb,
474 struct snd_kcontrol_new *kctl,
475 struct gb_audio_control *ctl)
477 struct gbaudio_ctl_pvt *ctldata;
479 ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),
483 ctldata->ctl_id = ctl->id;
484 ctldata->data_cport = ctl->data_cport;
485 ctldata->access = ctl->access;
486 ctldata->vcount = ctl->count_values;
487 ctldata->info = &ctl->info;
488 *kctl = (struct snd_kcontrol_new)
489 SOC_DAPM_MIXER_GB(ctl->name, ctl->count, ctldata);
494 static int gbaudio_tplg_create_wcontrol(struct gbaudio_codec_info *gb,
495 struct snd_kcontrol_new *kctl,
496 struct gb_audio_control *ctl)
500 switch (ctl->iface) {
501 case SNDRV_CTL_ELEM_IFACE_MIXER:
502 switch (ctl->info.type) {
503 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
504 ret = gbaudio_tplg_create_enum_ctl(gb, kctl, ctl);
507 ret = gbaudio_tplg_create_mixer_ctl(gb, kctl, ctl);
516 dev_dbg(gb->dev, "%s:%d DAPM control created, ret:%d\n", ctl->name,
521 static int gbaudio_widget_event(struct snd_soc_dapm_widget *w,
522 struct snd_kcontrol *kcontrol, int event)
526 struct snd_soc_codec *codec = w->codec;
527 struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
528 struct gbaudio_codec_info *gbcodec = audio->gbcodec;
530 dev_dbg(codec->dev, "%s %s %d\n", __func__, w->name, event);
532 /* map name to widget id */
533 wid = gbaudio_map_widgetname(gbcodec, w->name);
535 dev_err(codec->dev, "Invalid widget name:%s\n", w->name);
540 case SND_SOC_DAPM_PRE_PMU:
541 ret = gb_audio_gb_enable_widget(gbcodec->mgmt_connection, wid);
543 case SND_SOC_DAPM_POST_PMD:
544 ret = gb_audio_gb_disable_widget(gbcodec->mgmt_connection, wid);
548 dev_err(codec->dev, "%d: widget, event:%d failed:%d\n", wid,
553 static int gbaudio_tplg_create_widget(struct gbaudio_codec_info *gbcodec,
554 struct snd_soc_dapm_widget *dw,
555 struct gb_audio_widget *w)
558 struct snd_kcontrol_new *widget_kctls;
559 struct gb_audio_control *curr;
560 struct gbaudio_control *control, *_control;
563 ret = gbaudio_validate_kcontrol_count(w);
565 dev_err(gbcodec->dev, "Inavlid kcontrol count=%d for %s\n",
566 w->ncontrols, w->name);
570 /* allocate memory for kcontrol */
572 size = sizeof(struct snd_kcontrol_new) * w->ncontrols;
573 widget_kctls = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
578 /* create relevant kcontrols */
579 for (i = 0; i < w->ncontrols; i++) {
581 ret = gbaudio_tplg_create_wcontrol(gbcodec, &widget_kctls[i],
584 dev_err(gbcodec->dev,
585 "%s:%d type widget_ctl not supported\n",
586 curr->name, curr->iface);
589 control = devm_kzalloc(gbcodec->dev,
590 sizeof(struct gbaudio_control),
596 control->id = curr->id;
597 control->name = curr->name;
598 if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED)
599 control->texts = (const char * const *)
600 curr->info.value.enumerated.names;
601 list_add(&control->list, &gbcodec->widget_ctl_list);
602 dev_dbg(gbcodec->dev, "%s: control of type %d created\n",
603 widget_kctls[i].name, widget_kctls[i].iface);
607 case snd_soc_dapm_spk:
608 *dw = (struct snd_soc_dapm_widget)
609 SND_SOC_DAPM_SPK(w->name, gbcodec_event_spk);
611 case snd_soc_dapm_hp:
612 *dw = (struct snd_soc_dapm_widget)
613 SND_SOC_DAPM_HP(w->name, gbcodec_event_hp);
615 case snd_soc_dapm_mic:
616 *dw = (struct snd_soc_dapm_widget)
617 SND_SOC_DAPM_MIC(w->name, gbcodec_event_int_mic);
619 case snd_soc_dapm_output:
620 *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_OUTPUT(w->name);
622 case snd_soc_dapm_input:
623 *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_INPUT(w->name);
625 case snd_soc_dapm_switch:
626 *dw = (struct snd_soc_dapm_widget)
627 SND_SOC_DAPM_SWITCH_E(w->name, SND_SOC_NOPM, 0, 0,
628 widget_kctls, gbaudio_widget_event,
629 SND_SOC_DAPM_PRE_PMU |
630 SND_SOC_DAPM_POST_PMD);
632 case snd_soc_dapm_pga:
633 *dw = (struct snd_soc_dapm_widget)
634 SND_SOC_DAPM_PGA_E(w->name, SND_SOC_NOPM, 0, 0, NULL, 0,
635 gbaudio_widget_event,
636 SND_SOC_DAPM_PRE_PMU |
637 SND_SOC_DAPM_POST_PMD);
639 case snd_soc_dapm_mixer:
640 *dw = (struct snd_soc_dapm_widget)
641 SND_SOC_DAPM_MIXER_E(w->name, SND_SOC_NOPM, 0, 0, NULL,
642 0, gbaudio_widget_event,
643 SND_SOC_DAPM_PRE_PMU |
644 SND_SOC_DAPM_POST_PMD);
646 case snd_soc_dapm_mux:
647 *dw = (struct snd_soc_dapm_widget)
648 SND_SOC_DAPM_MUX_E(w->name, SND_SOC_NOPM, 0, 0,
649 widget_kctls, gbaudio_widget_event,
650 SND_SOC_DAPM_PRE_PMU |
651 SND_SOC_DAPM_POST_PMD);
653 case snd_soc_dapm_aif_in:
654 *dw = (struct snd_soc_dapm_widget)
655 SND_SOC_DAPM_AIF_IN_E(w->name, w->sname, 0,
657 0, 0, gbaudio_widget_event,
658 SND_SOC_DAPM_PRE_PMU |
659 SND_SOC_DAPM_POST_PMD);
661 case snd_soc_dapm_aif_out:
662 *dw = (struct snd_soc_dapm_widget)
663 SND_SOC_DAPM_AIF_OUT_E(w->name, w->sname, 0,
665 0, 0, gbaudio_widget_event,
666 SND_SOC_DAPM_PRE_PMU |
667 SND_SOC_DAPM_POST_PMD);
674 dev_dbg(gbcodec->dev, "%s: widget of type %d created\n", dw->name,
678 list_for_each_entry_safe(control, _control, &gbcodec->widget_ctl_list,
680 list_del(&control->list);
681 devm_kfree(gbcodec->dev, control);
686 static int gbaudio_tplg_create_dai(struct gbaudio_codec_info *gbcodec,
687 struct snd_soc_dai_driver *gb_dai,
688 struct gb_audio_dai *dai)
691 * do not update name here,
692 * append dev_id before assigning it here
695 gb_dai->playback.stream_name = dai->playback.stream_name;
696 gb_dai->playback.channels_min = dai->playback.chan_min;
697 gb_dai->playback.channels_max = dai->playback.chan_max;
698 gb_dai->playback.formats = dai->playback.formats;
699 gb_dai->playback.rates = dai->playback.rates;
700 gb_dai->playback.sig_bits = dai->playback.sig_bits;
702 gb_dai->capture.stream_name = dai->capture.stream_name;
703 gb_dai->capture.channels_min = dai->capture.chan_min;
704 gb_dai->capture.channels_max = dai->capture.chan_max;
705 gb_dai->capture.formats = dai->capture.formats;
706 gb_dai->capture.rates = dai->capture.rates;
707 gb_dai->capture.sig_bits = dai->capture.sig_bits;
712 static int gbaudio_tplg_process_kcontrols(struct gbaudio_codec_info *gbcodec,
713 struct gb_audio_control *controls)
716 struct snd_kcontrol_new *dapm_kctls;
717 struct gb_audio_control *curr;
718 struct gbaudio_control *control, *_control;
721 size = sizeof(struct snd_kcontrol_new) * gbcodec->num_kcontrols;
722 dapm_kctls = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
727 for (i = 0; i < gbcodec->num_kcontrols; i++) {
728 ret = gbaudio_tplg_create_kcontrol(gbcodec, &dapm_kctls[i],
731 dev_err(gbcodec->dev, "%s:%d type not supported\n",
732 curr->name, curr->iface);
735 control = devm_kzalloc(gbcodec->dev, sizeof(struct
742 control->id = curr->id;
743 control->name = curr->name;
744 if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED)
745 control->texts = (const char * const *)
746 curr->info.value.enumerated.names;
747 list_add(&control->list, &gbcodec->codec_ctl_list);
748 dev_dbg(gbcodec->dev, "%d:%s created of type %d\n", curr->id,
749 curr->name, curr->info.type);
752 gbcodec->kctls = dapm_kctls;
756 list_for_each_entry_safe(control, _control, &gbcodec->codec_ctl_list,
758 list_del(&control->list);
759 devm_kfree(gbcodec->dev, control);
761 devm_kfree(gbcodec->dev, dapm_kctls);
765 static int gbaudio_tplg_process_widgets(struct gbaudio_codec_info *gbcodec,
766 struct gb_audio_widget *widgets)
768 int i, ret, ncontrols;
769 struct snd_soc_dapm_widget *dapm_widgets;
770 struct gb_audio_widget *curr;
771 struct gbaudio_widget *widget, *_widget;
774 size = sizeof(struct snd_soc_dapm_widget) * gbcodec->num_dapm_widgets;
775 dapm_widgets = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
780 for (i = 0; i < gbcodec->num_dapm_widgets; i++) {
781 ret = gbaudio_tplg_create_widget(gbcodec, &dapm_widgets[i],
784 dev_err(gbcodec->dev, "%s:%d type not supported\n",
785 curr->name, curr->type);
788 widget = devm_kzalloc(gbcodec->dev, sizeof(struct
795 widget->id = curr->id;
796 widget->name = curr->name;
797 list_add(&widget->list, &gbcodec->widget_list);
798 ncontrols = curr->ncontrols;
800 curr += ncontrols * sizeof(struct gb_audio_control);
802 gbcodec->widgets = dapm_widgets;
807 list_for_each_entry_safe(widget, _widget, &gbcodec->widget_list,
809 list_del(&widget->list);
810 devm_kfree(gbcodec->dev, widget);
812 devm_kfree(gbcodec->dev, dapm_widgets);
816 static int gbaudio_tplg_process_dais(struct gbaudio_codec_info *gbcodec,
817 struct gb_audio_dai *dais)
820 struct snd_soc_dai_driver *gb_dais;
821 struct gb_audio_dai *curr;
822 struct gbaudio_dai *dai, *_dai;
824 char dai_name[NAME_SIZE];
826 size = sizeof(struct snd_soc_dai_driver) * gbcodec->num_dais;
827 gb_dais = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
832 for (i = 0; i < gbcodec->num_dais; i++) {
833 ret = gbaudio_tplg_create_dai(gbcodec, &gb_dais[i], curr);
835 dev_err(gbcodec->dev, "%s failed to create\n",
839 /* append dev_id to dai_name */
840 snprintf(dai_name, NAME_SIZE, "%s.%d", curr->name,
842 dai = gbaudio_add_dai(gbcodec, curr->data_cport, NULL,
846 dev_dbg(gbcodec->dev, "%s:DAI added\n", dai->name);
847 gb_dais[i].name = dai->name;
850 gbcodec->dais = gb_dais;
855 list_for_each_entry_safe(dai, _dai, &gbcodec->dai_list, list) {
856 list_del(&dai->list);
857 devm_kfree(gbcodec->dev, dai);
859 devm_kfree(gbcodec->dev, gb_dais);
863 static int gbaudio_tplg_process_routes(struct gbaudio_codec_info *gbcodec,
864 struct gb_audio_route *routes)
867 struct snd_soc_dapm_route *dapm_routes;
868 struct gb_audio_route *curr;
871 size = sizeof(struct snd_soc_dapm_route) * gbcodec->num_dapm_routes;
872 dapm_routes = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
877 gbcodec->routes = dapm_routes;
880 for (i = 0; i < gbcodec->num_dapm_routes; i++) {
882 gbaudio_map_widgetid(gbcodec, curr->destination_id);
883 if (!dapm_routes->sink) {
884 dev_err(gbcodec->dev, "%d:%d:%d:%d - Invalid sink\n",
885 curr->source_id, curr->destination_id,
886 curr->control_id, curr->index);
890 dapm_routes->source =
891 gbaudio_map_widgetid(gbcodec, curr->source_id);
892 if (!dapm_routes->source) {
893 dev_err(gbcodec->dev, "%d:%d:%d:%d - Invalid source\n",
894 curr->source_id, curr->destination_id,
895 curr->control_id, curr->index);
899 dapm_routes->control =
900 gbaudio_map_controlid(gbcodec,
903 if ((curr->control_id != GBAUDIO_INVALID_ID) &&
904 !dapm_routes->control) {
905 dev_err(gbcodec->dev, "%d:%d:%d:%d - Invalid control\n",
906 curr->source_id, curr->destination_id,
907 curr->control_id, curr->index);
911 dev_dbg(gbcodec->dev, "Route {%s, %s, %s}\n", dapm_routes->sink,
912 (dapm_routes->control) ? dapm_routes->control:"NULL",
913 dapm_routes->source);
921 devm_kfree(gbcodec->dev, dapm_routes);
925 static int gbaudio_tplg_process_header(struct gbaudio_codec_info *gbcodec,
926 struct gb_audio_topology *tplg_data)
928 /* fetch no. of kcontrols, widgets & routes */
929 gbcodec->num_dais = tplg_data->num_dais;
930 gbcodec->num_kcontrols = tplg_data->num_controls;
931 gbcodec->num_dapm_widgets = tplg_data->num_widgets;
932 gbcodec->num_dapm_routes = tplg_data->num_routes;
934 /* update block offset */
935 gbcodec->dai_offset = (unsigned long)&tplg_data->data;
936 gbcodec->control_offset = gbcodec->dai_offset + tplg_data->size_dais;
937 gbcodec->widget_offset = gbcodec->control_offset +
938 tplg_data->size_controls;
939 gbcodec->route_offset = gbcodec->widget_offset +
940 tplg_data->size_widgets;
942 dev_dbg(gbcodec->dev, "DAI offset is 0x%lx\n", gbcodec->dai_offset);
943 dev_dbg(gbcodec->dev, "control offset is %lx\n",
944 gbcodec->control_offset);
945 dev_dbg(gbcodec->dev, "widget offset is %lx\n", gbcodec->widget_offset);
946 dev_dbg(gbcodec->dev, "route offset is %lx\n", gbcodec->route_offset);
951 static struct gbaudio_dai *gbaudio_allocate_dai(struct gbaudio_codec_info *gb,
953 struct gb_connection *connection,
956 struct gbaudio_dai *dai;
958 mutex_lock(&gb->lock);
959 dai = devm_kzalloc(gb->dev, sizeof(*dai), GFP_KERNEL);
961 dev_err(gb->dev, "%s:DAI Malloc failure\n", name);
962 mutex_unlock(&gb->lock);
966 dai->data_cport = data_cport;
967 dai->connection = connection;
971 strlcpy(dai->name, name, NAME_SIZE);
972 list_add(&dai->list, &gb->dai_list);
973 dev_dbg(gb->dev, "%d:%s: DAI added\n", data_cport, dai->name);
974 mutex_unlock(&gb->lock);
979 struct gbaudio_dai *gbaudio_add_dai(struct gbaudio_codec_info *gbcodec,
981 struct gb_connection *connection,
984 struct gbaudio_dai *dai, *_dai;
986 /* FIXME need to take care for multiple DAIs */
987 mutex_lock(&gbcodec->lock);
988 if (list_empty(&gbcodec->dai_list)) {
989 mutex_unlock(&gbcodec->lock);
990 return gbaudio_allocate_dai(gbcodec, data_cport, connection,
994 list_for_each_entry_safe(dai, _dai, &gbcodec->dai_list, list) {
995 if (dai->data_cport == data_cport) {
997 dai->connection = connection;
1000 strlcpy(dai->name, name, NAME_SIZE);
1001 dev_dbg(gbcodec->dev, "%d:%s: DAI updated\n",
1002 data_cport, dai->name);
1003 mutex_unlock(&gbcodec->lock);
1008 dev_err(gbcodec->dev, "%s:DAI not found\n", name);
1009 mutex_unlock(&gbcodec->lock);
1013 int gbaudio_tplg_parse_data(struct gbaudio_codec_info *gbcodec,
1014 struct gb_audio_topology *tplg_data)
1017 struct gb_audio_dai *dais;
1018 struct gb_audio_control *controls;
1019 struct gb_audio_widget *widgets;
1020 struct gb_audio_route *routes;
1025 ret = gbaudio_tplg_process_header(gbcodec, tplg_data);
1027 dev_err(gbcodec->dev, "%d: Error in parsing topology header\n",
1032 /* process control */
1033 controls = (struct gb_audio_control *)gbcodec->control_offset;
1034 ret = gbaudio_tplg_process_kcontrols(gbcodec, controls);
1036 dev_err(gbcodec->dev,
1037 "%d: Error in parsing controls data\n", ret);
1040 dev_dbg(gbcodec->dev, "Control parsing finished\n");
1043 dais = (struct gb_audio_dai *)gbcodec->dai_offset;
1044 ret = gbaudio_tplg_process_dais(gbcodec, dais);
1046 dev_err(gbcodec->dev,
1047 "%d: Error in parsing DAIs data\n", ret);
1050 dev_dbg(gbcodec->dev, "DAI parsing finished\n");
1052 /* process widgets */
1053 widgets = (struct gb_audio_widget *)gbcodec->widget_offset;
1054 ret = gbaudio_tplg_process_widgets(gbcodec, widgets);
1056 dev_err(gbcodec->dev,
1057 "%d: Error in parsing widgets data\n", ret);
1060 dev_dbg(gbcodec->dev, "Widget parsing finished\n");
1063 routes = (struct gb_audio_route *)gbcodec->route_offset;
1064 ret = gbaudio_tplg_process_routes(gbcodec, routes);
1066 dev_err(gbcodec->dev,
1067 "%d: Error in parsing routes data\n", ret);
1070 dev_dbg(gbcodec->dev, "Route parsing finished\n");
1075 void gbaudio_tplg_release(struct gbaudio_codec_info *gbcodec)
1077 struct gbaudio_dai *dai, *_dai;
1078 struct gbaudio_control *control, *_control;
1079 struct gbaudio_widget *widget, *_widget;
1081 if (!gbcodec->topology)
1084 /* release kcontrols */
1085 list_for_each_entry_safe(control, _control, &gbcodec->codec_ctl_list,
1087 list_del(&control->list);
1088 devm_kfree(gbcodec->dev, control);
1091 devm_kfree(gbcodec->dev, gbcodec->kctls);
1093 /* release widget controls */
1094 list_for_each_entry_safe(control, _control, &gbcodec->widget_ctl_list,
1096 list_del(&control->list);
1097 devm_kfree(gbcodec->dev, control);
1100 /* release widgets */
1101 list_for_each_entry_safe(widget, _widget, &gbcodec->widget_list,
1103 list_del(&widget->list);
1104 devm_kfree(gbcodec->dev, widget);
1106 if (gbcodec->widgets)
1107 devm_kfree(gbcodec->dev, gbcodec->widgets);
1109 /* release routes */
1110 if (gbcodec->routes)
1111 devm_kfree(gbcodec->dev, gbcodec->routes);
1114 mutex_lock(&gbcodec->lock);
1115 list_for_each_entry_safe(dai, _dai, &gbcodec->dai_list, list) {
1116 list_del(&dai->list);
1117 devm_kfree(gbcodec->dev, dai);
1119 mutex_unlock(&gbcodec->lock);