drivers/staging/greybus/audio_topology.c

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