1
2
3
4
5
6
7
8#include <linux/greybus.h>
9#include "audio_codec.h"
10
11#define GBAUDIO_INVALID_ID 0xFF
12
13
14struct gb_mixer_control {
15 int min, max;
16 unsigned int reg, rreg, shift, rshift, invert;
17};
18
19struct gbaudio_ctl_pvt {
20 unsigned int ctl_id;
21 unsigned int data_cport;
22 unsigned int access;
23 unsigned int vcount;
24 struct gb_audio_ctl_elem_info *info;
25};
26
27static struct gbaudio_module_info *find_gb_module(
28 struct gbaudio_codec_info *codec,
29 char const *name)
30{
31 int dev_id;
32 char begin[NAME_SIZE];
33 struct gbaudio_module_info *module;
34
35 if (!name)
36 return NULL;
37
38 if (sscanf(name, "%s %d", begin, &dev_id) != 2)
39 return NULL;
40
41 dev_dbg(codec->dev, "%s:Find module#%d\n", __func__, dev_id);
42
43 mutex_lock(&codec->lock);
44 list_for_each_entry(module, &codec->module_list, list) {
45 if (module->dev_id == dev_id) {
46 mutex_unlock(&codec->lock);
47 return module;
48 }
49 }
50 mutex_unlock(&codec->lock);
51 dev_warn(codec->dev, "%s: module#%d missing in codec list\n", name,
52 dev_id);
53 return NULL;
54}
55
56static const char *gbaudio_map_controlid(struct gbaudio_module_info *module,
57 __u8 control_id, __u8 index)
58{
59 struct gbaudio_control *control;
60
61 if (control_id == GBAUDIO_INVALID_ID)
62 return NULL;
63
64 list_for_each_entry(control, &module->ctl_list, list) {
65 if (control->id == control_id) {
66 if (index == GBAUDIO_INVALID_ID)
67 return control->name;
68 if (index >= control->items)
69 return NULL;
70 return control->texts[index];
71 }
72 }
73 list_for_each_entry(control, &module->widget_ctl_list, list) {
74 if (control->id == control_id) {
75 if (index == GBAUDIO_INVALID_ID)
76 return control->name;
77 if (index >= control->items)
78 return NULL;
79 return control->texts[index];
80 }
81 }
82 return NULL;
83}
84
85static int gbaudio_map_controlname(struct gbaudio_module_info *module,
86 const char *name)
87{
88 struct gbaudio_control *control;
89
90 list_for_each_entry(control, &module->ctl_list, list) {
91 if (!strncmp(control->name, name, NAME_SIZE))
92 return control->id;
93 }
94
95 dev_warn(module->dev, "%s: missing in modules controls list\n", name);
96
97 return -EINVAL;
98}
99
100static int gbaudio_map_wcontrolname(struct gbaudio_module_info *module,
101 const char *name)
102{
103 struct gbaudio_control *control;
104
105 list_for_each_entry(control, &module->widget_ctl_list, list) {
106 if (!strncmp(control->wname, name, NAME_SIZE))
107 return control->id;
108 }
109 dev_warn(module->dev, "%s: missing in modules controls list\n", name);
110
111 return -EINVAL;
112}
113
114static int gbaudio_map_widgetname(struct gbaudio_module_info *module,
115 const char *name)
116{
117 struct gbaudio_widget *widget;
118
119 list_for_each_entry(widget, &module->widget_list, list) {
120 if (!strncmp(widget->name, name, NAME_SIZE))
121 return widget->id;
122 }
123 dev_warn(module->dev, "%s: missing in modules widgets list\n", name);
124
125 return -EINVAL;
126}
127
128static const char *gbaudio_map_widgetid(struct gbaudio_module_info *module,
129 __u8 widget_id)
130{
131 struct gbaudio_widget *widget;
132
133 list_for_each_entry(widget, &module->widget_list, list) {
134 if (widget->id == widget_id)
135 return widget->name;
136 }
137 return NULL;
138}
139
140static const char **gb_generate_enum_strings(struct gbaudio_module_info *gb,
141 struct gb_audio_enumerated *gbenum)
142{
143 const char **strings;
144 int i;
145 unsigned int items;
146 __u8 *data;
147
148 items = le32_to_cpu(gbenum->items);
149 strings = devm_kcalloc(gb->dev, items, sizeof(char *), GFP_KERNEL);
150 data = gbenum->names;
151
152 for (i = 0; i < items; i++) {
153 strings[i] = (const char *)data;
154 while (*data != '\0')
155 data++;
156 data++;
157 }
158
159 return strings;
160}
161
162static int gbcodec_mixer_ctl_info(struct snd_kcontrol *kcontrol,
163 struct snd_ctl_elem_info *uinfo)
164{
165 unsigned int max;
166 const char *name;
167 struct gbaudio_ctl_pvt *data;
168 struct gb_audio_ctl_elem_info *info;
169 struct gbaudio_module_info *module;
170 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
171 struct gbaudio_codec_info *gbcodec = snd_soc_component_get_drvdata(comp);
172
173 dev_dbg(comp->dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
174 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
175 info = (struct gb_audio_ctl_elem_info *)data->info;
176
177 if (!info) {
178 dev_err(comp->dev, "NULL info for %s\n", uinfo->id.name);
179 return -EINVAL;
180 }
181
182
183 uinfo->access = data->access;
184 uinfo->count = data->vcount;
185 uinfo->type = (__force snd_ctl_elem_type_t)info->type;
186
187 switch (info->type) {
188 case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
189 case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
190 uinfo->value.integer.min = le32_to_cpu(info->value.integer.min);
191 uinfo->value.integer.max = le32_to_cpu(info->value.integer.max);
192 break;
193 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
194 max = le32_to_cpu(info->value.enumerated.items);
195 uinfo->value.enumerated.items = max;
196 if (uinfo->value.enumerated.item > max - 1)
197 uinfo->value.enumerated.item = max - 1;
198 module = find_gb_module(gbcodec, kcontrol->id.name);
199 if (!module)
200 return -EINVAL;
201 name = gbaudio_map_controlid(module, data->ctl_id,
202 uinfo->value.enumerated.item);
203 strscpy(uinfo->value.enumerated.name, name, sizeof(uinfo->value.enumerated.name));
204 break;
205 default:
206 dev_err(comp->dev, "Invalid type: %d for %s:kcontrol\n",
207 info->type, kcontrol->id.name);
208 break;
209 }
210 return 0;
211}
212
213static int gbcodec_mixer_ctl_get(struct snd_kcontrol *kcontrol,
214 struct snd_ctl_elem_value *ucontrol)
215{
216 int ret;
217 struct gb_audio_ctl_elem_info *info;
218 struct gbaudio_ctl_pvt *data;
219 struct gb_audio_ctl_elem_value gbvalue;
220 struct gbaudio_module_info *module;
221 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
222 struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
223 struct gb_bundle *bundle;
224
225 dev_dbg(comp->dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
226 module = find_gb_module(gb, kcontrol->id.name);
227 if (!module)
228 return -EINVAL;
229
230 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
231 info = (struct gb_audio_ctl_elem_info *)data->info;
232 bundle = to_gb_bundle(module->dev);
233
234 ret = gb_pm_runtime_get_sync(bundle);
235 if (ret)
236 return ret;
237
238 ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
239 GB_AUDIO_INVALID_INDEX, &gbvalue);
240
241 gb_pm_runtime_put_autosuspend(bundle);
242
243 if (ret) {
244 dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n", ret,
245 __func__, kcontrol->id.name);
246 return ret;
247 }
248
249
250 switch (info->type) {
251 case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
252 case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
253 ucontrol->value.integer.value[0] =
254 le32_to_cpu(gbvalue.value.integer_value[0]);
255 if (data->vcount == 2)
256 ucontrol->value.integer.value[1] =
257 le32_to_cpu(gbvalue.value.integer_value[1]);
258 break;
259 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
260 ucontrol->value.enumerated.item[0] =
261 le32_to_cpu(gbvalue.value.enumerated_item[0]);
262 if (data->vcount == 2)
263 ucontrol->value.enumerated.item[1] =
264 le32_to_cpu(gbvalue.value.enumerated_item[1]);
265 break;
266 default:
267 dev_err(comp->dev, "Invalid type: %d for %s:kcontrol\n",
268 info->type, kcontrol->id.name);
269 ret = -EINVAL;
270 break;
271 }
272 return ret;
273}
274
275static int gbcodec_mixer_ctl_put(struct snd_kcontrol *kcontrol,
276 struct snd_ctl_elem_value *ucontrol)
277{
278 int ret = 0;
279 struct gb_audio_ctl_elem_info *info;
280 struct gbaudio_ctl_pvt *data;
281 struct gb_audio_ctl_elem_value gbvalue;
282 struct gbaudio_module_info *module;
283 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
284 struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
285 struct gb_bundle *bundle;
286
287 dev_dbg(comp->dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
288 module = find_gb_module(gb, kcontrol->id.name);
289 if (!module)
290 return -EINVAL;
291
292 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
293 info = (struct gb_audio_ctl_elem_info *)data->info;
294 bundle = to_gb_bundle(module->dev);
295
296
297 switch (info->type) {
298 case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
299 case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
300 gbvalue.value.integer_value[0] =
301 cpu_to_le32(ucontrol->value.integer.value[0]);
302 if (data->vcount == 2)
303 gbvalue.value.integer_value[1] =
304 cpu_to_le32(ucontrol->value.integer.value[1]);
305 break;
306 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
307 gbvalue.value.enumerated_item[0] =
308 cpu_to_le32(ucontrol->value.enumerated.item[0]);
309 if (data->vcount == 2)
310 gbvalue.value.enumerated_item[1] =
311 cpu_to_le32(ucontrol->value.enumerated.item[1]);
312 break;
313 default:
314 dev_err(comp->dev, "Invalid type: %d for %s:kcontrol\n",
315 info->type, kcontrol->id.name);
316 ret = -EINVAL;
317 break;
318 }
319
320 if (ret)
321 return ret;
322
323 ret = gb_pm_runtime_get_sync(bundle);
324 if (ret)
325 return ret;
326
327 ret = gb_audio_gb_set_control(module->mgmt_connection, data->ctl_id,
328 GB_AUDIO_INVALID_INDEX, &gbvalue);
329
330 gb_pm_runtime_put_autosuspend(bundle);
331
332 if (ret) {
333 dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n", ret,
334 __func__, kcontrol->id.name);
335 }
336
337 return ret;
338}
339
340#define SOC_MIXER_GB(xname, kcount, data) \
341{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
342 .count = kcount, .info = gbcodec_mixer_ctl_info, \
343 .get = gbcodec_mixer_ctl_get, .put = gbcodec_mixer_ctl_put, \
344 .private_value = (unsigned long)data }
345
346
347
348
349
350
351static int gbcodec_mixer_dapm_ctl_info(struct snd_kcontrol *kcontrol,
352 struct snd_ctl_elem_info *uinfo)
353{
354 int platform_max, platform_min;
355 struct gbaudio_ctl_pvt *data;
356 struct gb_audio_ctl_elem_info *info;
357
358 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
359 info = (struct gb_audio_ctl_elem_info *)data->info;
360
361
362 platform_max = le32_to_cpu(info->value.integer.max);
363 platform_min = le32_to_cpu(info->value.integer.min);
364
365 if (platform_max == 1 &&
366 !strnstr(kcontrol->id.name, " Volume", sizeof(kcontrol->id.name)))
367 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
368 else
369 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
370
371 uinfo->count = data->vcount;
372 uinfo->value.integer.min = platform_min;
373 uinfo->value.integer.max = platform_max;
374
375 return 0;
376}
377
378static int gbcodec_mixer_dapm_ctl_get(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
380{
381 int ret;
382 struct gbaudio_ctl_pvt *data;
383 struct gb_audio_ctl_elem_value gbvalue;
384 struct gbaudio_module_info *module;
385 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
386 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
387 struct device *codec_dev = widget->dapm->dev;
388 struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
389 struct gb_bundle *bundle;
390
391 dev_dbg(codec_dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
392 module = find_gb_module(gb, kcontrol->id.name);
393 if (!module)
394 return -EINVAL;
395
396 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
397 bundle = to_gb_bundle(module->dev);
398
399 if (data->vcount == 2)
400 dev_warn(widget->dapm->dev,
401 "GB: Control '%s' is stereo, which is not supported\n",
402 kcontrol->id.name);
403
404 ret = gb_pm_runtime_get_sync(bundle);
405 if (ret)
406 return ret;
407
408 ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
409 GB_AUDIO_INVALID_INDEX, &gbvalue);
410
411 gb_pm_runtime_put_autosuspend(bundle);
412
413 if (ret) {
414 dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
415 __func__, kcontrol->id.name);
416 return ret;
417 }
418
419 ucontrol->value.integer.value[0] =
420 le32_to_cpu(gbvalue.value.integer_value[0]);
421
422 return ret;
423}
424
425static int gbcodec_mixer_dapm_ctl_put(struct snd_kcontrol *kcontrol,
426 struct snd_ctl_elem_value *ucontrol)
427{
428 int ret, wi, max, connect;
429 unsigned int mask, val;
430 struct gb_audio_ctl_elem_info *info;
431 struct gbaudio_ctl_pvt *data;
432 struct gb_audio_ctl_elem_value gbvalue;
433 struct gbaudio_module_info *module;
434 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
435 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
436 struct device *codec_dev = widget->dapm->dev;
437 struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
438 struct gb_bundle *bundle;
439
440 dev_dbg(codec_dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
441 module = find_gb_module(gb, kcontrol->id.name);
442 if (!module)
443 return -EINVAL;
444
445 data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
446 info = (struct gb_audio_ctl_elem_info *)data->info;
447 bundle = to_gb_bundle(module->dev);
448
449 if (data->vcount == 2)
450 dev_warn(widget->dapm->dev,
451 "GB: Control '%s' is stereo, which is not supported\n",
452 kcontrol->id.name);
453
454 max = le32_to_cpu(info->value.integer.max);
455 mask = (1 << fls(max)) - 1;
456 val = ucontrol->value.integer.value[0] & mask;
457 connect = !!val;
458
459 ret = gb_pm_runtime_get_sync(bundle);
460 if (ret)
461 return ret;
462
463 ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
464 GB_AUDIO_INVALID_INDEX, &gbvalue);
465 if (ret)
466 goto exit;
467
468
469 if (le32_to_cpu(gbvalue.value.integer_value[0]) != val) {
470 for (wi = 0; wi < wlist->num_widgets; wi++) {
471 widget = wlist->widgets[wi];
472 snd_soc_dapm_mixer_update_power(widget->dapm, kcontrol,
473 connect, NULL);
474 }
475 gbvalue.value.integer_value[0] =
476 cpu_to_le32(ucontrol->value.integer.value[0]);
477
478 ret = gb_audio_gb_set_control(module->mgmt_connection,
479 data->ctl_id,
480 GB_AUDIO_INVALID_INDEX, &gbvalue);
481 }
482
483exit:
484 gb_pm_runtime_put_autosuspend(bundle);
485 if (ret)
486 dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
487 __func__, kcontrol->id.name);
488 return ret;
489}
490
491#define SOC_DAPM_MIXER_GB(xname, kcount, data) \
492{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
493 .count = kcount, .info = gbcodec_mixer_dapm_ctl_info, \
494 .get = gbcodec_mixer_dapm_ctl_get, .put = gbcodec_mixer_dapm_ctl_put, \
495 .private_value = (unsigned long)data}
496
497static int gbcodec_event_spk(struct snd_soc_dapm_widget *w,
498 struct snd_kcontrol *k, int event)
499{
500
501
502 return 0;
503}
504
505static int gbcodec_event_hp(struct snd_soc_dapm_widget *w,
506 struct snd_kcontrol *k, int event)
507{
508
509
510 return 0;
511}
512
513static int gbcodec_event_int_mic(struct snd_soc_dapm_widget *w,
514 struct snd_kcontrol *k, int event)
515{
516
517
518 return 0;
519}
520
521static int gbaudio_validate_kcontrol_count(struct gb_audio_widget *w)
522{
523 int ret = 0;
524
525 switch (w->type) {
526 case snd_soc_dapm_spk:
527 case snd_soc_dapm_hp:
528 case snd_soc_dapm_mic:
529 case snd_soc_dapm_output:
530 case snd_soc_dapm_input:
531 if (w->ncontrols)
532 ret = -EINVAL;
533 break;
534 case snd_soc_dapm_switch:
535 case snd_soc_dapm_mux:
536 if (w->ncontrols != 1)
537 ret = -EINVAL;
538 break;
539 default:
540 break;
541 }
542
543 return ret;
544}
545
546static int gbcodec_enum_ctl_get(struct snd_kcontrol *kcontrol,
547 struct snd_ctl_elem_value *ucontrol)
548{
549 int ret, ctl_id;
550 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
551 struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
552 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
553 struct gb_audio_ctl_elem_value gbvalue;
554 struct gbaudio_module_info *module;
555 struct gb_bundle *bundle;
556
557 module = find_gb_module(gb, kcontrol->id.name);
558 if (!module)
559 return -EINVAL;
560
561 ctl_id = gbaudio_map_controlname(module, kcontrol->id.name);
562 if (ctl_id < 0)
563 return -EINVAL;
564
565 bundle = to_gb_bundle(module->dev);
566
567 ret = gb_pm_runtime_get_sync(bundle);
568 if (ret)
569 return ret;
570
571 ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,
572 GB_AUDIO_INVALID_INDEX, &gbvalue);
573
574 gb_pm_runtime_put_autosuspend(bundle);
575
576 if (ret) {
577 dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n", ret,
578 __func__, kcontrol->id.name);
579 return ret;
580 }
581
582 ucontrol->value.enumerated.item[0] =
583 le32_to_cpu(gbvalue.value.enumerated_item[0]);
584 if (e->shift_l != e->shift_r)
585 ucontrol->value.enumerated.item[1] =
586 le32_to_cpu(gbvalue.value.enumerated_item[1]);
587
588 return 0;
589}
590
591static int gbcodec_enum_ctl_put(struct snd_kcontrol *kcontrol,
592 struct snd_ctl_elem_value *ucontrol)
593{
594 int ret, ctl_id;
595 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
596 struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
597 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
598 struct gb_audio_ctl_elem_value gbvalue;
599 struct gbaudio_module_info *module;
600 struct gb_bundle *bundle;
601
602 module = find_gb_module(gb, kcontrol->id.name);
603 if (!module)
604 return -EINVAL;
605
606 ctl_id = gbaudio_map_controlname(module, kcontrol->id.name);
607 if (ctl_id < 0)
608 return -EINVAL;
609
610 if (ucontrol->value.enumerated.item[0] > e->items - 1)
611 return -EINVAL;
612 gbvalue.value.enumerated_item[0] =
613 cpu_to_le32(ucontrol->value.enumerated.item[0]);
614
615 if (e->shift_l != e->shift_r) {
616 if (ucontrol->value.enumerated.item[1] > e->items - 1)
617 return -EINVAL;
618 gbvalue.value.enumerated_item[1] =
619 cpu_to_le32(ucontrol->value.enumerated.item[1]);
620 }
621
622 bundle = to_gb_bundle(module->dev);
623
624 ret = gb_pm_runtime_get_sync(bundle);
625 if (ret)
626 return ret;
627
628 ret = gb_audio_gb_set_control(module->mgmt_connection, ctl_id,
629 GB_AUDIO_INVALID_INDEX, &gbvalue);
630
631 gb_pm_runtime_put_autosuspend(bundle);
632
633 if (ret) {
634 dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n",
635 ret, __func__, kcontrol->id.name);
636 }
637
638 return ret;
639}
640
641static int gbaudio_tplg_create_enum_kctl(struct gbaudio_module_info *gb,
642 struct snd_kcontrol_new *kctl,
643 struct gb_audio_control *ctl)
644{
645 struct soc_enum *gbe;
646 struct gb_audio_enumerated *gb_enum;
647 int i;
648
649 gbe = devm_kzalloc(gb->dev, sizeof(*gbe), GFP_KERNEL);
650 if (!gbe)
651 return -ENOMEM;
652
653 gb_enum = &ctl->info.value.enumerated;
654
655
656 gbe->items = le32_to_cpu(gb_enum->items);
657 gbe->texts = gb_generate_enum_strings(gb, gb_enum);
658
659
660 dev_dbg(gb->dev, "Max:%d, name_length:%d\n", gbe->items,
661 le16_to_cpu(gb_enum->names_length));
662 for (i = 0; i < gbe->items; i++)
663 dev_dbg(gb->dev, "src[%d]: %s\n", i, gbe->texts[i]);
664
665 *kctl = (struct snd_kcontrol_new)
666 SOC_ENUM_EXT(ctl->name, *gbe, gbcodec_enum_ctl_get,
667 gbcodec_enum_ctl_put);
668 return 0;
669}
670
671static int gbaudio_tplg_create_kcontrol(struct gbaudio_module_info *gb,
672 struct snd_kcontrol_new *kctl,
673 struct gb_audio_control *ctl)
674{
675 int ret = 0;
676 struct gbaudio_ctl_pvt *ctldata;
677
678 switch (ctl->iface) {
679 case (__force int)SNDRV_CTL_ELEM_IFACE_MIXER:
680 switch (ctl->info.type) {
681 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
682 ret = gbaudio_tplg_create_enum_kctl(gb, kctl, ctl);
683 break;
684 default:
685 ctldata = devm_kzalloc(gb->dev,
686 sizeof(struct gbaudio_ctl_pvt),
687 GFP_KERNEL);
688 if (!ctldata)
689 return -ENOMEM;
690 ctldata->ctl_id = ctl->id;
691 ctldata->data_cport = le16_to_cpu(ctl->data_cport);
692 ctldata->access = le32_to_cpu(ctl->access);
693 ctldata->vcount = ctl->count_values;
694 ctldata->info = &ctl->info;
695 *kctl = (struct snd_kcontrol_new)
696 SOC_MIXER_GB(ctl->name, ctl->count, ctldata);
697 ctldata = NULL;
698 break;
699 }
700 break;
701 default:
702 return -EINVAL;
703 }
704
705 dev_dbg(gb->dev, "%s:%d control created\n", ctl->name, ctl->id);
706 return ret;
707}
708
709static int gbcodec_enum_dapm_ctl_get(struct snd_kcontrol *kcontrol,
710 struct snd_ctl_elem_value *ucontrol)
711{
712 int ret, ctl_id;
713 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
714 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
715 struct gbaudio_module_info *module;
716 struct gb_audio_ctl_elem_value gbvalue;
717 struct device *codec_dev = widget->dapm->dev;
718 struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
719 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
720 struct gb_bundle *bundle;
721
722 module = find_gb_module(gb, kcontrol->id.name);
723 if (!module)
724 return -EINVAL;
725
726 ctl_id = gbaudio_map_wcontrolname(module, kcontrol->id.name);
727 if (ctl_id < 0)
728 return -EINVAL;
729
730 bundle = to_gb_bundle(module->dev);
731
732 ret = gb_pm_runtime_get_sync(bundle);
733 if (ret)
734 return ret;
735
736 ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,
737 GB_AUDIO_INVALID_INDEX, &gbvalue);
738
739 gb_pm_runtime_put_autosuspend(bundle);
740
741 if (ret) {
742 dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
743 __func__, kcontrol->id.name);
744 return ret;
745 }
746
747 ucontrol->value.enumerated.item[0] = le32_to_cpu(gbvalue.value.enumerated_item[0]);
748 if (e->shift_l != e->shift_r)
749 ucontrol->value.enumerated.item[1] =
750 le32_to_cpu(gbvalue.value.enumerated_item[1]);
751
752 return 0;
753}
754
755static int gbcodec_enum_dapm_ctl_put(struct snd_kcontrol *kcontrol,
756 struct snd_ctl_elem_value *ucontrol)
757{
758 int ret, wi, ctl_id;
759 unsigned int val, mux, change;
760 unsigned int mask;
761 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
762 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
763 struct gb_audio_ctl_elem_value gbvalue;
764 struct gbaudio_module_info *module;
765 struct device *codec_dev = widget->dapm->dev;
766 struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
767 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
768 struct gb_bundle *bundle;
769
770 if (ucontrol->value.enumerated.item[0] > e->items - 1)
771 return -EINVAL;
772
773 module = find_gb_module(gb, kcontrol->id.name);
774 if (!module)
775 return -EINVAL;
776
777 ctl_id = gbaudio_map_wcontrolname(module, kcontrol->id.name);
778 if (ctl_id < 0)
779 return -EINVAL;
780
781 change = 0;
782 bundle = to_gb_bundle(module->dev);
783
784 ret = gb_pm_runtime_get_sync(bundle);
785 if (ret)
786 return ret;
787
788 ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,
789 GB_AUDIO_INVALID_INDEX, &gbvalue);
790
791 gb_pm_runtime_put_autosuspend(bundle);
792
793 if (ret) {
794 dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
795 __func__, kcontrol->id.name);
796 return ret;
797 }
798
799 mux = ucontrol->value.enumerated.item[0];
800 val = mux << e->shift_l;
801 mask = e->mask << e->shift_l;
802
803 if (le32_to_cpu(gbvalue.value.enumerated_item[0]) !=
804 ucontrol->value.enumerated.item[0]) {
805 change = 1;
806 gbvalue.value.enumerated_item[0] =
807 cpu_to_le32(ucontrol->value.enumerated.item[0]);
808 }
809
810 if (e->shift_l != e->shift_r) {
811 if (ucontrol->value.enumerated.item[1] > e->items - 1)
812 return -EINVAL;
813 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
814 mask |= e->mask << e->shift_r;
815 if (le32_to_cpu(gbvalue.value.enumerated_item[1]) !=
816 ucontrol->value.enumerated.item[1]) {
817 change = 1;
818 gbvalue.value.enumerated_item[1] =
819 cpu_to_le32(ucontrol->value.enumerated.item[1]);
820 }
821 }
822
823 if (change) {
824 ret = gb_pm_runtime_get_sync(bundle);
825 if (ret)
826 return ret;
827
828 ret = gb_audio_gb_set_control(module->mgmt_connection, ctl_id,
829 GB_AUDIO_INVALID_INDEX, &gbvalue);
830
831 gb_pm_runtime_put_autosuspend(bundle);
832
833 if (ret) {
834 dev_err_ratelimited(codec_dev,
835 "%d:Error in %s for %s\n", ret,
836 __func__, kcontrol->id.name);
837 }
838 for (wi = 0; wi < wlist->num_widgets; wi++) {
839 widget = wlist->widgets[wi];
840 snd_soc_dapm_mux_update_power(widget->dapm, kcontrol,
841 val, e, NULL);
842 }
843 }
844
845 return change;
846}
847
848static int gbaudio_tplg_create_enum_ctl(struct gbaudio_module_info *gb,
849 struct snd_kcontrol_new *kctl,
850 struct gb_audio_control *ctl)
851{
852 struct soc_enum *gbe;
853 struct gb_audio_enumerated *gb_enum;
854 int i;
855
856 gbe = devm_kzalloc(gb->dev, sizeof(*gbe), GFP_KERNEL);
857 if (!gbe)
858 return -ENOMEM;
859
860 gb_enum = &ctl->info.value.enumerated;
861
862
863 gbe->items = le32_to_cpu(gb_enum->items);
864 gbe->texts = gb_generate_enum_strings(gb, gb_enum);
865
866
867 dev_dbg(gb->dev, "Max:%d, name_length:%d\n", gbe->items,
868 le16_to_cpu(gb_enum->names_length));
869 for (i = 0; i < gbe->items; i++)
870 dev_dbg(gb->dev, "src[%d]: %s\n", i, gbe->texts[i]);
871
872 *kctl = (struct snd_kcontrol_new)
873 SOC_DAPM_ENUM_EXT(ctl->name, *gbe, gbcodec_enum_dapm_ctl_get,
874 gbcodec_enum_dapm_ctl_put);
875 return 0;
876}
877
878static int gbaudio_tplg_create_mixer_ctl(struct gbaudio_module_info *gb,
879 struct snd_kcontrol_new *kctl,
880 struct gb_audio_control *ctl)
881{
882 struct gbaudio_ctl_pvt *ctldata;
883
884 ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),
885 GFP_KERNEL);
886 if (!ctldata)
887 return -ENOMEM;
888 ctldata->ctl_id = ctl->id;
889 ctldata->data_cport = le16_to_cpu(ctl->data_cport);
890 ctldata->access = le32_to_cpu(ctl->access);
891 ctldata->vcount = ctl->count_values;
892 ctldata->info = &ctl->info;
893 *kctl = (struct snd_kcontrol_new)
894 SOC_DAPM_MIXER_GB(ctl->name, ctl->count, ctldata);
895
896 return 0;
897}
898
899static int gbaudio_tplg_create_wcontrol(struct gbaudio_module_info *gb,
900 struct snd_kcontrol_new *kctl,
901 struct gb_audio_control *ctl)
902{
903 int ret;
904
905 switch (ctl->iface) {
906 case (__force int)SNDRV_CTL_ELEM_IFACE_MIXER:
907 switch (ctl->info.type) {
908 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
909 ret = gbaudio_tplg_create_enum_ctl(gb, kctl, ctl);
910 break;
911 default:
912 ret = gbaudio_tplg_create_mixer_ctl(gb, kctl, ctl);
913 break;
914 }
915 break;
916 default:
917 return -EINVAL;
918 }
919
920 dev_dbg(gb->dev, "%s:%d DAPM control created, ret:%d\n", ctl->name,
921 ctl->id, ret);
922 return ret;
923}
924
925static int gbaudio_widget_event(struct snd_soc_dapm_widget *w,
926 struct snd_kcontrol *kcontrol, int event)
927{
928 int wid;
929 int ret;
930 struct device *codec_dev = w->dapm->dev;
931 struct gbaudio_codec_info *gbcodec = dev_get_drvdata(codec_dev);
932 struct gbaudio_module_info *module;
933 struct gb_bundle *bundle;
934
935 dev_dbg(codec_dev, "%s %s %d\n", __func__, w->name, event);
936
937
938 module = find_gb_module(gbcodec, w->name);
939 if (!module)
940 return -EINVAL;
941
942
943 wid = gbaudio_map_widgetname(module, w->name);
944 if (wid < 0) {
945 dev_err(codec_dev, "Invalid widget name:%s\n", w->name);
946 return -EINVAL;
947 }
948
949 bundle = to_gb_bundle(module->dev);
950
951 ret = gb_pm_runtime_get_sync(bundle);
952 if (ret)
953 return ret;
954
955 switch (event) {
956 case SND_SOC_DAPM_PRE_PMU:
957 ret = gb_audio_gb_enable_widget(module->mgmt_connection, wid);
958 if (!ret)
959 ret = gbaudio_module_update(gbcodec, w, module, 1);
960 break;
961 case SND_SOC_DAPM_POST_PMD:
962 ret = gb_audio_gb_disable_widget(module->mgmt_connection, wid);
963 if (!ret)
964 ret = gbaudio_module_update(gbcodec, w, module, 0);
965 break;
966 }
967 if (ret)
968 dev_err_ratelimited(codec_dev,
969 "%d: widget, event:%d failed:%d\n", wid,
970 event, ret);
971
972 gb_pm_runtime_put_autosuspend(bundle);
973
974 return ret;
975}
976
977static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module,
978 struct snd_soc_dapm_widget *dw,
979 struct gb_audio_widget *w, int *w_size)
980{
981 int i, ret, csize;
982 struct snd_kcontrol_new *widget_kctls;
983 struct gb_audio_control *curr;
984 struct gbaudio_control *control, *_control;
985 size_t size;
986 char temp_name[NAME_SIZE];
987
988 ret = gbaudio_validate_kcontrol_count(w);
989 if (ret) {
990 dev_err(module->dev, "Invalid kcontrol count=%d for %s\n",
991 w->ncontrols, w->name);
992 return ret;
993 }
994
995
996 if (w->ncontrols) {
997 size = sizeof(struct snd_kcontrol_new) * w->ncontrols;
998 widget_kctls = devm_kzalloc(module->dev, size, GFP_KERNEL);
999 if (!widget_kctls)
1000 return -ENOMEM;
1001 }
1002
1003 *w_size = sizeof(struct gb_audio_widget);
1004
1005
1006 curr = w->ctl;
1007 for (i = 0; i < w->ncontrols; i++) {
1008 ret = gbaudio_tplg_create_wcontrol(module, &widget_kctls[i],
1009 curr);
1010 if (ret) {
1011 dev_err(module->dev,
1012 "%s:%d type widget_ctl not supported\n",
1013 curr->name, curr->iface);
1014 goto error;
1015 }
1016 control = devm_kzalloc(module->dev,
1017 sizeof(struct gbaudio_control),
1018 GFP_KERNEL);
1019 if (!control) {
1020 ret = -ENOMEM;
1021 goto error;
1022 }
1023 control->id = curr->id;
1024 control->name = curr->name;
1025 control->wname = w->name;
1026
1027 if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) {
1028 struct gb_audio_enumerated *gbenum =
1029 &curr->info.value.enumerated;
1030
1031 csize = offsetof(struct gb_audio_control, info);
1032 csize += offsetof(struct gb_audio_ctl_elem_info, value);
1033 csize += offsetof(struct gb_audio_enumerated, names);
1034 csize += le16_to_cpu(gbenum->names_length);
1035 control->texts = (const char * const *)
1036 gb_generate_enum_strings(module, gbenum);
1037 control->items = le32_to_cpu(gbenum->items);
1038 } else {
1039 csize = sizeof(struct gb_audio_control);
1040 }
1041
1042 *w_size += csize;
1043 curr = (void *)curr + csize;
1044 list_add(&control->list, &module->widget_ctl_list);
1045 dev_dbg(module->dev, "%s: control of type %d created\n",
1046 widget_kctls[i].name, widget_kctls[i].iface);
1047 }
1048
1049
1050 strscpy(temp_name, w->name, sizeof(temp_name));
1051 snprintf(w->name, sizeof(w->name), "GB %d %s", module->dev_id, temp_name);
1052
1053 switch (w->type) {
1054 case snd_soc_dapm_spk:
1055 *dw = (struct snd_soc_dapm_widget)
1056 SND_SOC_DAPM_SPK(w->name, gbcodec_event_spk);
1057 module->op_devices |= GBAUDIO_DEVICE_OUT_SPEAKER;
1058 break;
1059 case snd_soc_dapm_hp:
1060 *dw = (struct snd_soc_dapm_widget)
1061 SND_SOC_DAPM_HP(w->name, gbcodec_event_hp);
1062 module->op_devices |= (GBAUDIO_DEVICE_OUT_WIRED_HEADSET
1063 | GBAUDIO_DEVICE_OUT_WIRED_HEADPHONE);
1064 module->ip_devices |= GBAUDIO_DEVICE_IN_WIRED_HEADSET;
1065 break;
1066 case snd_soc_dapm_mic:
1067 *dw = (struct snd_soc_dapm_widget)
1068 SND_SOC_DAPM_MIC(w->name, gbcodec_event_int_mic);
1069 module->ip_devices |= GBAUDIO_DEVICE_IN_BUILTIN_MIC;
1070 break;
1071 case snd_soc_dapm_output:
1072 *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_OUTPUT(w->name);
1073 break;
1074 case snd_soc_dapm_input:
1075 *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_INPUT(w->name);
1076 break;
1077 case snd_soc_dapm_switch:
1078 *dw = (struct snd_soc_dapm_widget)
1079 SND_SOC_DAPM_SWITCH_E(w->name, SND_SOC_NOPM, 0, 0,
1080 widget_kctls,
1081 gbaudio_widget_event,
1082 SND_SOC_DAPM_PRE_PMU |
1083 SND_SOC_DAPM_POST_PMD);
1084 break;
1085 case snd_soc_dapm_pga:
1086 *dw = (struct snd_soc_dapm_widget)
1087 SND_SOC_DAPM_PGA_E(w->name, SND_SOC_NOPM, 0, 0, NULL, 0,
1088 gbaudio_widget_event,
1089 SND_SOC_DAPM_PRE_PMU |
1090 SND_SOC_DAPM_POST_PMD);
1091 break;
1092 case snd_soc_dapm_mixer:
1093 *dw = (struct snd_soc_dapm_widget)
1094 SND_SOC_DAPM_MIXER_E(w->name, SND_SOC_NOPM, 0, 0, NULL,
1095 0, gbaudio_widget_event,
1096 SND_SOC_DAPM_PRE_PMU |
1097 SND_SOC_DAPM_POST_PMD);
1098 break;
1099 case snd_soc_dapm_mux:
1100 *dw = (struct snd_soc_dapm_widget)
1101 SND_SOC_DAPM_MUX_E(w->name, SND_SOC_NOPM, 0, 0,
1102 widget_kctls, gbaudio_widget_event,
1103 SND_SOC_DAPM_PRE_PMU |
1104 SND_SOC_DAPM_POST_PMD);
1105 break;
1106 case snd_soc_dapm_aif_in:
1107 *dw = (struct snd_soc_dapm_widget)
1108 SND_SOC_DAPM_AIF_IN_E(w->name, w->sname, 0,
1109 SND_SOC_NOPM,
1110 0, 0, gbaudio_widget_event,
1111 SND_SOC_DAPM_PRE_PMU |
1112 SND_SOC_DAPM_POST_PMD);
1113 break;
1114 case snd_soc_dapm_aif_out:
1115 *dw = (struct snd_soc_dapm_widget)
1116 SND_SOC_DAPM_AIF_OUT_E(w->name, w->sname, 0,
1117 SND_SOC_NOPM,
1118 0, 0, gbaudio_widget_event,
1119 SND_SOC_DAPM_PRE_PMU |
1120 SND_SOC_DAPM_POST_PMD);
1121 break;
1122 default:
1123 ret = -EINVAL;
1124 goto error;
1125 }
1126
1127 dev_dbg(module->dev, "%s: widget of type %d created\n", dw->name,
1128 dw->id);
1129 return 0;
1130error:
1131 list_for_each_entry_safe(control, _control, &module->widget_ctl_list,
1132 list) {
1133 list_del(&control->list);
1134 devm_kfree(module->dev, control);
1135 }
1136 return ret;
1137}
1138
1139static int gbaudio_tplg_process_kcontrols(struct gbaudio_module_info *module,
1140 struct gb_audio_control *controls)
1141{
1142 int i, csize, ret;
1143 struct snd_kcontrol_new *dapm_kctls;
1144 struct gb_audio_control *curr;
1145 struct gbaudio_control *control, *_control;
1146 size_t size;
1147 char temp_name[NAME_SIZE];
1148
1149 size = sizeof(struct snd_kcontrol_new) * module->num_controls;
1150 dapm_kctls = devm_kzalloc(module->dev, size, GFP_KERNEL);
1151 if (!dapm_kctls)
1152 return -ENOMEM;
1153
1154 curr = controls;
1155 for (i = 0; i < module->num_controls; i++) {
1156 ret = gbaudio_tplg_create_kcontrol(module, &dapm_kctls[i],
1157 curr);
1158 if (ret) {
1159 dev_err(module->dev, "%s:%d type not supported\n",
1160 curr->name, curr->iface);
1161 goto error;
1162 }
1163 control = devm_kzalloc(module->dev, sizeof(struct
1164 gbaudio_control),
1165 GFP_KERNEL);
1166 if (!control) {
1167 ret = -ENOMEM;
1168 goto error;
1169 }
1170 control->id = curr->id;
1171
1172 strscpy(temp_name, curr->name, sizeof(temp_name));
1173 snprintf(curr->name, sizeof(curr->name), "GB %d %s", module->dev_id,
1174 temp_name);
1175 control->name = curr->name;
1176 if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) {
1177 struct gb_audio_enumerated *gbenum =
1178 &curr->info.value.enumerated;
1179
1180 csize = offsetof(struct gb_audio_control, info);
1181 csize += offsetof(struct gb_audio_ctl_elem_info, value);
1182 csize += offsetof(struct gb_audio_enumerated, names);
1183 csize += le16_to_cpu(gbenum->names_length);
1184 control->texts = (const char * const *)
1185 gb_generate_enum_strings(module, gbenum);
1186 control->items = le32_to_cpu(gbenum->items);
1187 } else {
1188 csize = sizeof(struct gb_audio_control);
1189 }
1190
1191 list_add(&control->list, &module->ctl_list);
1192 dev_dbg(module->dev, "%d:%s created of type %d\n", curr->id,
1193 curr->name, curr->info.type);
1194 curr = (void *)curr + csize;
1195 }
1196 module->controls = dapm_kctls;
1197
1198 return 0;
1199error:
1200 list_for_each_entry_safe(control, _control, &module->ctl_list,
1201 list) {
1202 list_del(&control->list);
1203 devm_kfree(module->dev, control);
1204 }
1205 devm_kfree(module->dev, dapm_kctls);
1206 return ret;
1207}
1208
1209static int gbaudio_tplg_process_widgets(struct gbaudio_module_info *module,
1210 struct gb_audio_widget *widgets)
1211{
1212 int i, ret, w_size;
1213 struct snd_soc_dapm_widget *dapm_widgets;
1214 struct gb_audio_widget *curr;
1215 struct gbaudio_widget *widget, *_widget;
1216 size_t size;
1217
1218 size = sizeof(struct snd_soc_dapm_widget) * module->num_dapm_widgets;
1219 dapm_widgets = devm_kzalloc(module->dev, size, GFP_KERNEL);
1220 if (!dapm_widgets)
1221 return -ENOMEM;
1222
1223 curr = widgets;
1224 for (i = 0; i < module->num_dapm_widgets; i++) {
1225 ret = gbaudio_tplg_create_widget(module, &dapm_widgets[i],
1226 curr, &w_size);
1227 if (ret) {
1228 dev_err(module->dev, "%s:%d type not supported\n",
1229 curr->name, curr->type);
1230 goto error;
1231 }
1232 widget = devm_kzalloc(module->dev, sizeof(struct
1233 gbaudio_widget),
1234 GFP_KERNEL);
1235 if (!widget) {
1236 ret = -ENOMEM;
1237 goto error;
1238 }
1239 widget->id = curr->id;
1240 widget->name = curr->name;
1241 list_add(&widget->list, &module->widget_list);
1242 curr = (void *)curr + w_size;
1243 }
1244 module->dapm_widgets = dapm_widgets;
1245
1246 return 0;
1247
1248error:
1249 list_for_each_entry_safe(widget, _widget, &module->widget_list,
1250 list) {
1251 list_del(&widget->list);
1252 devm_kfree(module->dev, widget);
1253 }
1254 devm_kfree(module->dev, dapm_widgets);
1255 return ret;
1256}
1257
1258static int gbaudio_tplg_process_routes(struct gbaudio_module_info *module,
1259 struct gb_audio_route *routes)
1260{
1261 int i, ret;
1262 struct snd_soc_dapm_route *dapm_routes;
1263 struct gb_audio_route *curr;
1264 size_t size;
1265
1266 size = sizeof(struct snd_soc_dapm_route) * module->num_dapm_routes;
1267 dapm_routes = devm_kzalloc(module->dev, size, GFP_KERNEL);
1268 if (!dapm_routes)
1269 return -ENOMEM;
1270
1271 module->dapm_routes = dapm_routes;
1272 curr = routes;
1273
1274 for (i = 0; i < module->num_dapm_routes; i++) {
1275 dapm_routes->sink =
1276 gbaudio_map_widgetid(module, curr->destination_id);
1277 if (!dapm_routes->sink) {
1278 dev_err(module->dev, "%d:%d:%d:%d - Invalid sink\n",
1279 curr->source_id, curr->destination_id,
1280 curr->control_id, curr->index);
1281 ret = -EINVAL;
1282 goto error;
1283 }
1284 dapm_routes->source =
1285 gbaudio_map_widgetid(module, curr->source_id);
1286 if (!dapm_routes->source) {
1287 dev_err(module->dev, "%d:%d:%d:%d - Invalid source\n",
1288 curr->source_id, curr->destination_id,
1289 curr->control_id, curr->index);
1290 ret = -EINVAL;
1291 goto error;
1292 }
1293 dapm_routes->control =
1294 gbaudio_map_controlid(module,
1295 curr->control_id,
1296 curr->index);
1297 if ((curr->control_id != GBAUDIO_INVALID_ID) &&
1298 !dapm_routes->control) {
1299 dev_err(module->dev, "%d:%d:%d:%d - Invalid control\n",
1300 curr->source_id, curr->destination_id,
1301 curr->control_id, curr->index);
1302 ret = -EINVAL;
1303 goto error;
1304 }
1305 dev_dbg(module->dev, "Route {%s, %s, %s}\n", dapm_routes->sink,
1306 (dapm_routes->control) ? dapm_routes->control : "NULL",
1307 dapm_routes->source);
1308 dapm_routes++;
1309 curr++;
1310 }
1311
1312 return 0;
1313
1314error:
1315 devm_kfree(module->dev, module->dapm_routes);
1316 return ret;
1317}
1318
1319static int gbaudio_tplg_process_header(struct gbaudio_module_info *module,
1320 struct gb_audio_topology *tplg_data)
1321{
1322
1323 module->num_controls = tplg_data->num_controls;
1324 module->num_dapm_widgets = tplg_data->num_widgets;
1325 module->num_dapm_routes = tplg_data->num_routes;
1326
1327
1328 module->dai_offset = (unsigned long)&tplg_data->data;
1329 module->control_offset = module->dai_offset +
1330 le32_to_cpu(tplg_data->size_dais);
1331 module->widget_offset = module->control_offset +
1332 le32_to_cpu(tplg_data->size_controls);
1333 module->route_offset = module->widget_offset +
1334 le32_to_cpu(tplg_data->size_widgets);
1335
1336 dev_dbg(module->dev, "DAI offset is 0x%lx\n", module->dai_offset);
1337 dev_dbg(module->dev, "control offset is %lx\n",
1338 module->control_offset);
1339 dev_dbg(module->dev, "widget offset is %lx\n", module->widget_offset);
1340 dev_dbg(module->dev, "route offset is %lx\n", module->route_offset);
1341
1342 return 0;
1343}
1344
1345int gbaudio_tplg_parse_data(struct gbaudio_module_info *module,
1346 struct gb_audio_topology *tplg_data)
1347{
1348 int ret;
1349 struct gb_audio_control *controls;
1350 struct gb_audio_widget *widgets;
1351 struct gb_audio_route *routes;
1352 unsigned int jack_type;
1353
1354 if (!tplg_data)
1355 return -EINVAL;
1356
1357 ret = gbaudio_tplg_process_header(module, tplg_data);
1358 if (ret) {
1359 dev_err(module->dev, "%d: Error in parsing topology header\n",
1360 ret);
1361 return ret;
1362 }
1363
1364
1365 controls = (struct gb_audio_control *)module->control_offset;
1366 ret = gbaudio_tplg_process_kcontrols(module, controls);
1367 if (ret) {
1368 dev_err(module->dev,
1369 "%d: Error in parsing controls data\n", ret);
1370 return ret;
1371 }
1372 dev_dbg(module->dev, "Control parsing finished\n");
1373
1374
1375 widgets = (struct gb_audio_widget *)module->widget_offset;
1376 ret = gbaudio_tplg_process_widgets(module, widgets);
1377 if (ret) {
1378 dev_err(module->dev,
1379 "%d: Error in parsing widgets data\n", ret);
1380 return ret;
1381 }
1382 dev_dbg(module->dev, "Widget parsing finished\n");
1383
1384
1385 routes = (struct gb_audio_route *)module->route_offset;
1386 ret = gbaudio_tplg_process_routes(module, routes);
1387 if (ret) {
1388 dev_err(module->dev,
1389 "%d: Error in parsing routes data\n", ret);
1390 return ret;
1391 }
1392 dev_dbg(module->dev, "Route parsing finished\n");
1393
1394
1395 jack_type = le32_to_cpu(tplg_data->jack_type);
1396 if (jack_type) {
1397 module->jack_mask = jack_type & GBCODEC_JACK_MASK;
1398 module->button_mask = jack_type & GBCODEC_JACK_BUTTON_MASK;
1399 }
1400
1401 return ret;
1402}
1403
1404void gbaudio_tplg_release(struct gbaudio_module_info *module)
1405{
1406 struct gbaudio_control *control, *_control;
1407 struct gbaudio_widget *widget, *_widget;
1408
1409 if (!module->topology)
1410 return;
1411
1412
1413 list_for_each_entry_safe(control, _control, &module->ctl_list,
1414 list) {
1415 list_del(&control->list);
1416 devm_kfree(module->dev, control);
1417 }
1418 if (module->controls)
1419 devm_kfree(module->dev, module->controls);
1420
1421
1422 list_for_each_entry_safe(control, _control, &module->widget_ctl_list,
1423 list) {
1424 list_del(&control->list);
1425 devm_kfree(module->dev, control);
1426 }
1427
1428
1429 list_for_each_entry_safe(widget, _widget, &module->widget_list,
1430 list) {
1431 list_del(&widget->list);
1432 devm_kfree(module->dev, widget);
1433 }
1434 if (module->dapm_widgets)
1435 devm_kfree(module->dev, module->dapm_widgets);
1436
1437
1438 if (module->dapm_routes)
1439 devm_kfree(module->dev, module->dapm_routes);
1440}
1441
