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