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