drivers/staging/greybus/audio_topology.c

   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 /* mixer control */
  14 struct gb_mixer_control {
  15         int min, max;
  16         unsigned int reg, rreg, shift, rshift, invert;
  17 };
  18
  19 struct 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
  27 static 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
  56 static 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
  85 static 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
 100 static 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
 114 static 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
 128 static 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
 140 static 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
 162 static 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         /* update uinfo */
 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
 213 static 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         /* update ucontrol */
 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
 275 static 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         /* update ucontrol */
 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  * although below callback functions seems redundant to above functions.
 348  * same are kept to allow provision for different handling in case
 349  * of DAPM related sequencing, etc.
 350  */
 351 static 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         /* update uinfo */
 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
 378 static 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         /* update ucontrol */
 419         ucontrol->value.integer.value[0] =
 420                 le32_to_cpu(gbvalue.value.integer_value[0]);
 421
 422         return ret;
 423 }
 424
 425 static 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         /* update ucontrol */
 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
 483 exit:
 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
 497 static int gbcodec_event_spk(struct snd_soc_dapm_widget *w,
 498                              struct snd_kcontrol *k, int event)
 499 {
 500         /* Ensure GB speaker is connected */
 501
 502         return 0;
 503 }
 504
 505 static int gbcodec_event_hp(struct snd_soc_dapm_widget *w,
 506                             struct snd_kcontrol *k, int event)
 507 {
 508         /* Ensure GB module supports jack slot */
 509
 510         return 0;
 511 }
 512
 513 static int gbcodec_event_int_mic(struct snd_soc_dapm_widget *w,
 514                                  struct snd_kcontrol *k, int event)
 515 {
 516         /* Ensure GB module supports jack slot */
 517
 518         return 0;
 519 }
 520
 521 static 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
 546 static 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
 591 static 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
 641 static 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         /* since count=1, and reg is dummy */
 656         gbe->items = le32_to_cpu(gb_enum->items);
 657         gbe->texts = gb_generate_enum_strings(gb, gb_enum);
 658
 659         /* debug enum info */
 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
 671 static 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
 709 static 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
 755 static 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
 848 static 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         /* since count=1, and reg is dummy */
 863         gbe->items = le32_to_cpu(gb_enum->items);
 864         gbe->texts = gb_generate_enum_strings(gb, gb_enum);
 865
 866         /* debug enum info */
 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
 878 static 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
 899 static 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
 925 static 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         /* Find relevant module */
 938         module = find_gb_module(gbcodec, w->name);
 939         if (!module)
 940                 return -EINVAL;
 941
 942         /* map name to widget id */
 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
 977 static 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         /* allocate memory for kcontrol */
 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         /* create relevant kcontrols */
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         /* Prefix dev_id to widget control_name */
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;
1130 error:
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
1139 static 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                 /* Prefix dev_id to widget_name */
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;
1199 error:
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
1209 static 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
1248 error:
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
1258 static 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
1314 error:
1315         devm_kfree(module->dev, module->dapm_routes);
1316         return ret;
1317 }
1318
1319 static int gbaudio_tplg_process_header(struct gbaudio_module_info *module,
1320                                        struct gb_audio_topology *tplg_data)
1321 {
1322         /* fetch no. of kcontrols, widgets & routes */
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         /* update block offset */
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
1345 int 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         /* process control */
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         /* process widgets */
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         /* process route */
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         /* parse jack capabilities */
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
1404 void 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         /* release kcontrols */
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         /* release widget controls */
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         /* release widgets */
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         /* release routes */
1438         if (module->dapm_routes)
1439                 devm_kfree(module->dev, module->dapm_routes);
1440 }