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