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 const char *gbaudio_map_controlid(struct gbaudio_codec_info *gbcodec,
  29                                            __u8 control_id, __u8 index)
  30 {
  31         struct gbaudio_control *control;
  32
  33         if (control_id == GBAUDIO_INVALID_ID)
  34                 return NULL;
  35
  36         list_for_each_entry(control, &gbcodec->codec_ctl_list, list) {
  37                 if (control->id == control_id) {
  38                         if (index == GBAUDIO_INVALID_ID)
  39                                 return control->name;
  40                         return control->texts[index];
  41                 }
  42         }
  43         list_for_each_entry(control, &gbcodec->widget_ctl_list, list) {
  44                 if (control->id == control_id) {
  45                         if (index == GBAUDIO_INVALID_ID)
  46                                 return control->name;
  47                         return control->texts[index];
  48                 }
  49         }
  50         return NULL;
  51 }
  52
  53 static int gbaudio_map_widgetname(struct gbaudio_codec_info *gbcodec,
  54                                           const char *name)
  55 {
  56         struct gbaudio_widget *widget;
  57         char widget_name[NAME_SIZE];
  58         char prefix_name[NAME_SIZE];
  59
  60         snprintf(prefix_name, NAME_SIZE, "GB %d ", gbcodec->dev_id);
  61         if (strncmp(name, prefix_name, strlen(prefix_name)))
  62                 return -EINVAL;
  63
  64         strlcpy(widget_name, name+strlen(prefix_name), NAME_SIZE);
  65         dev_dbg(gbcodec->dev, "widget_name:%s, truncated widget_name:%s\n",
  66                 name, widget_name);
  67
  68         list_for_each_entry(widget, &gbcodec->widget_list, list) {
  69                 if (!strncmp(widget->name, widget_name, NAME_SIZE))
  70                         return widget->id;
  71         }
  72         return -EINVAL;
  73 }
  74
  75 static const char *gbaudio_map_widgetid(struct gbaudio_codec_info *gbcodec,
  76                                           __u8 widget_id)
  77 {
  78         struct gbaudio_widget *widget;
  79
  80         list_for_each_entry(widget, &gbcodec->widget_list, list) {
  81                 if (widget->id == widget_id)
  82                         return widget->name;
  83         }
  84         return NULL;
  85 }
  86
  87 static int gbcodec_mixer_ctl_info(struct snd_kcontrol *kcontrol,
  88                      struct snd_ctl_elem_info *uinfo)
  89 {
  90         unsigned int max;
  91         const char *name;
  92         struct gbaudio_ctl_pvt *data;
  93         struct gb_audio_ctl_elem_info *info;
  94         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
  95         struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
  96         struct gbaudio_codec_info *gbcodec = audio->gbcodec;
  97
  98         data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
  99         info = (struct gb_audio_ctl_elem_info *)data->info;
 100
 101         if (!info) {
 102                 dev_err(gbcodec->dev, "NULL info for %s\n", uinfo->id.name);
 103                 return -EINVAL;
 104         }
 105
 106         /* update uinfo */
 107         uinfo->access = data->access;
 108         uinfo->count = data->vcount;
 109         uinfo->type = (snd_ctl_elem_type_t)info->type;
 110
 111         switch (info->type) {
 112         case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
 113         case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
 114                 uinfo->value.integer.min = info->value.integer.min;
 115                 uinfo->value.integer.max = info->value.integer.max;
 116                 break;
 117         case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
 118                 max = info->value.enumerated.items;
 119                 uinfo->value.enumerated.items = max;
 120                 if (uinfo->value.enumerated.item > max - 1)
 121                         uinfo->value.enumerated.item = max - 1;
 122                 name = gbaudio_map_controlid(gbcodec, data->ctl_id,
 123                                              uinfo->value.enumerated.item);
 124                 strlcpy(uinfo->value.enumerated.name, name, NAME_SIZE);
 125                 break;
 126         default:
 127                 dev_err(codec->dev, "Invalid type: %d for %s:kcontrol\n",
 128                         info->type, kcontrol->id.name);
 129                 break;
 130         }
 131         return 0;
 132 }
 133
 134 static int gbcodec_mixer_ctl_get(struct snd_kcontrol *kcontrol,
 135         struct snd_ctl_elem_value *ucontrol)
 136 {
 137         int ret;
 138         struct gb_audio_ctl_elem_info *info;
 139         struct gbaudio_ctl_pvt *data;
 140         struct gb_audio_ctl_elem_value gbvalue;
 141         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 142         struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
 143         struct gbaudio_codec_info *gb = audio->gbcodec;
 144
 145         data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
 146         info = (struct gb_audio_ctl_elem_info *)data->info;
 147
 148         ret = gb_audio_gb_get_control(gb->mgmt_connection, data->ctl_id,
 149                                       GB_AUDIO_INVALID_INDEX, &gbvalue);
 150         if (ret) {
 151                 dev_err(codec->dev, "%d:Error in %s for %s\n", ret, __func__,
 152                         kcontrol->id.name);
 153                 return ret;
 154         }
 155
 156         /* update ucontrol */
 157         switch (info->type) {
 158         case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
 159         case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
 160                 ucontrol->value.integer.value[0] =
 161                         gbvalue.value.integer_value[0];
 162                 if (data->vcount == 2)
 163                         ucontrol->value.integer.value[1] =
 164                                 gbvalue.value.integer_value[1];
 165                 break;
 166         case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
 167                 ucontrol->value.enumerated.item[0] =
 168                         gbvalue.value.enumerated_item[0];
 169                 if (data->vcount == 2)
 170                         ucontrol->value.enumerated.item[1] =
 171                                 gbvalue.value.enumerated_item[1];
 172                 break;
 173         default:
 174                 dev_err(codec->dev, "Invalid type: %d for %s:kcontrol\n",
 175                         info->type, kcontrol->id.name);
 176                 ret = -EINVAL;
 177                 break;
 178         }
 179         return ret;
 180 }
 181
 182 static int gbcodec_mixer_ctl_put(struct snd_kcontrol *kcontrol,
 183                               struct snd_ctl_elem_value *ucontrol)
 184 {
 185         int ret = 0;
 186         struct gb_audio_ctl_elem_info *info;
 187         struct gbaudio_ctl_pvt *data;
 188         struct gb_audio_ctl_elem_value gbvalue;
 189         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 190         struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
 191         struct gbaudio_codec_info *gb = audio->gbcodec;
 192
 193         data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
 194         info = (struct gb_audio_ctl_elem_info *)data->info;
 195
 196         /* update ucontrol */
 197         switch (info->type) {
 198         case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
 199         case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
 200                 gbvalue.value.integer_value[0] =
 201                         ucontrol->value.integer.value[0];
 202                 if (data->vcount == 2)
 203                         gbvalue.value.integer_value[1] =
 204                                 ucontrol->value.integer.value[1];
 205                 break;
 206         case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
 207                 gbvalue.value.enumerated_item[0] =
 208                         ucontrol->value.enumerated.item[0];
 209                 if (data->vcount == 2)
 210                         gbvalue.value.enumerated_item[1] =
 211                                 ucontrol->value.enumerated.item[1];
 212                 break;
 213         default:
 214                 dev_err(codec->dev, "Invalid type: %d for %s:kcontrol\n",
 215                         info->type, kcontrol->id.name);
 216                 ret = -EINVAL;
 217                 break;
 218         }
 219
 220         if (ret)
 221                 return ret;
 222
 223         ret = gb_audio_gb_set_control(gb->mgmt_connection, data->ctl_id,
 224                                       GB_AUDIO_INVALID_INDEX, &gbvalue);
 225         if (ret) {
 226                 dev_err(codec->dev, "%d:Error in %s for %s\n", ret, __func__,
 227                         kcontrol->id.name);
 228         }
 229
 230         return ret;
 231 }
 232
 233 #define SOC_MIXER_GB(xname, kcount, data) \
 234 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 235         .count = kcount, .info = gbcodec_mixer_ctl_info, \
 236         .get = gbcodec_mixer_ctl_get, .put = gbcodec_mixer_ctl_put, \
 237         .private_value = (unsigned long)data }
 238
 239 /*
 240  * although below callback functions seems redundant to above functions.
 241  * same are kept to allow provision for different handling in case
 242  * of DAPM related sequencing, etc.
 243  */
 244 static int gbcodec_mixer_dapm_ctl_info(struct snd_kcontrol *kcontrol,
 245                      struct snd_ctl_elem_info *uinfo)
 246 {
 247         int platform_max, platform_min;
 248         struct gbaudio_ctl_pvt *data;
 249         struct gb_audio_ctl_elem_info *info;
 250
 251         data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
 252         info = (struct gb_audio_ctl_elem_info *)data->info;
 253
 254         /* update uinfo */
 255         platform_max = info->value.integer.max;
 256         platform_min = info->value.integer.min;
 257
 258         if (platform_max == 1 &&
 259             !strnstr(kcontrol->id.name, " Volume", NAME_SIZE))
 260                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 261         else
 262                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 263
 264         uinfo->count = data->vcount;
 265         uinfo->value.integer.min = 0;
 266         if (info->value.integer.min < 0 &&
 267             (uinfo->type == SNDRV_CTL_ELEM_TYPE_INTEGER))
 268                 uinfo->value.integer.max = platform_max - platform_min;
 269         else
 270                 uinfo->value.integer.max = platform_max;
 271
 272         return 0;
 273 }
 274
 275 static int gbcodec_mixer_dapm_ctl_get(struct snd_kcontrol *kcontrol,
 276         struct snd_ctl_elem_value *ucontrol)
 277 {
 278         int ret;
 279         struct gb_audio_ctl_elem_info *info;
 280         struct gbaudio_ctl_pvt *data;
 281         struct gb_audio_ctl_elem_value gbvalue;
 282         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
 283         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
 284         struct snd_soc_codec *codec = widget->codec;
 285         struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
 286         struct gbaudio_codec_info *gb = audio->gbcodec;
 287
 288         data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
 289         info = (struct gb_audio_ctl_elem_info *)data->info;
 290
 291         if (data->vcount == 2)
 292                 dev_warn(widget->dapm->dev,
 293                          "GB: Control '%s' is stereo, which is not supported\n",
 294                          kcontrol->id.name);
 295
 296         ret = gb_audio_gb_get_control(gb->mgmt_connection, data->ctl_id,
 297                                       GB_AUDIO_INVALID_INDEX, &gbvalue);
 298         if (ret) {
 299                 dev_err(codec->dev, "%d:Error in %s for %s\n", ret, __func__,
 300                         kcontrol->id.name);
 301                 return ret;
 302         }
 303         /* update ucontrol */
 304         ucontrol->value.integer.value[0] = gbvalue.value.integer_value[0];
 305
 306         return ret;
 307 }
 308
 309 static int gbcodec_mixer_dapm_ctl_put(struct snd_kcontrol *kcontrol,
 310                               struct snd_ctl_elem_value *ucontrol)
 311 {
 312         int ret, wi, max, connect;
 313         unsigned int mask, val;
 314         struct gb_audio_ctl_elem_info *info;
 315         struct gbaudio_ctl_pvt *data;
 316         struct gb_audio_ctl_elem_value gbvalue;
 317         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
 318         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
 319         struct snd_soc_codec *codec = widget->codec;
 320         struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
 321         struct gbaudio_codec_info *gb = audio->gbcodec;
 322
 323         data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
 324         info = (struct gb_audio_ctl_elem_info *)data->info;
 325
 326         if (data->vcount == 2)
 327                 dev_warn(widget->dapm->dev,
 328                          "GB: Control '%s' is stereo, which is not supported\n",
 329                          kcontrol->id.name);
 330
 331         max = info->value.integer.max;
 332         mask = (1 << fls(max)) - 1;
 333         val = (ucontrol->value.integer.value[0] & mask);
 334         connect = !!val;
 335
 336         /* update ucontrol */
 337         if (gbvalue.value.integer_value[0] != val) {
 338                 for (wi = 0; wi < wlist->num_widgets; wi++) {
 339                         widget = wlist->widgets[wi];
 340
 341                         widget->value = val;
 342                         widget->dapm->update = NULL;
 343                         snd_soc_dapm_mixer_update_power(widget, kcontrol,
 344                                                         connect);
 345                 }
 346                 gbvalue.value.integer_value[0] =
 347                         ucontrol->value.integer.value[0];
 348                 ret = gb_audio_gb_set_control(gb->mgmt_connection,
 349                                               data->ctl_id,
 350                                               GB_AUDIO_INVALID_INDEX, &gbvalue);
 351                 if (ret) {
 352                         dev_err(codec->dev,
 353                                 "%d:Error in %s for %s\n", ret, __func__,
 354                                 kcontrol->id.name);
 355                 }
 356         }
 357
 358         return ret;
 359 }
 360
 361 #define SOC_DAPM_MIXER_GB(xname, kcount, data) \
 362 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 363         .count = kcount, .info = gbcodec_mixer_dapm_ctl_info, \
 364         .get = gbcodec_mixer_dapm_ctl_get, .put = gbcodec_mixer_dapm_ctl_put, \
 365         .private_value = (unsigned long)data}
 366
 367 static int gbcodec_event_spk(struct snd_soc_dapm_widget *w,
 368                                         struct snd_kcontrol *k, int event)
 369 {
 370         /* Ensure GB speaker is connected */
 371
 372         return 0;
 373 }
 374
 375 static int gbcodec_event_hp(struct snd_soc_dapm_widget *w,
 376                                         struct snd_kcontrol *k, int event)
 377 {
 378         /* Ensure GB module supports jack slot */
 379
 380         return 0;
 381 }
 382
 383 static int gbcodec_event_int_mic(struct snd_soc_dapm_widget *w,
 384                                         struct snd_kcontrol *k, int event)
 385 {
 386         /* Ensure GB module supports jack slot */
 387
 388         return 0;
 389 }
 390
 391 static int gbaudio_validate_kcontrol_count(struct gb_audio_widget *w)
 392 {
 393         int ret = 0;
 394
 395         switch (w->type) {
 396         case snd_soc_dapm_spk:
 397         case snd_soc_dapm_hp:
 398         case snd_soc_dapm_mic:
 399         case snd_soc_dapm_output:
 400         case snd_soc_dapm_input:
 401                 if (w->ncontrols)
 402                         ret = -EINVAL;
 403                 break;
 404         case snd_soc_dapm_switch:
 405         case snd_soc_dapm_mux:
 406                 if (w->ncontrols != 1)
 407                         ret = -EINVAL;
 408                 break;
 409         default:
 410                 break;
 411         }
 412
 413         return ret;
 414 }
 415
 416 static int gbaudio_tplg_create_kcontrol(struct gbaudio_codec_info *gb,
 417                                         struct snd_kcontrol_new *kctl,
 418                                         struct gb_audio_control *ctl)
 419 {
 420         struct gbaudio_ctl_pvt *ctldata;
 421
 422         switch (ctl->iface) {
 423         case SNDRV_CTL_ELEM_IFACE_MIXER:
 424                 ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),
 425                                        GFP_KERNEL);
 426                 if (!ctldata)
 427                         return -ENOMEM;
 428                 ctldata->ctl_id = ctl->id;
 429                 ctldata->data_cport = ctl->data_cport;
 430                 ctldata->access = ctl->access;
 431                 ctldata->vcount = ctl->count_values;
 432                 ctldata->info = &ctl->info;
 433                 *kctl = (struct snd_kcontrol_new)
 434                         SOC_MIXER_GB(ctl->name, ctl->count, ctldata);
 435                 ctldata = NULL;
 436                 break;
 437         default:
 438                 return -EINVAL;
 439         }
 440
 441         dev_dbg(gb->dev, "%s:%d control created\n", ctl->name, ctl->id);
 442         return 0;
 443 }
 444
 445 static const char * const gbtexts[] = {"Stereo", "Left", "Right"};
 446
 447 static const SOC_ENUM_SINGLE_DECL(
 448         gbcodec_apb1_rx_enum, GBCODEC_APB1_MUX_REG, 0, gbtexts);
 449
 450 static const SOC_ENUM_SINGLE_DECL(
 451         gbcodec_mic_enum, GBCODEC_APB1_MUX_REG, 4, gbtexts);
 452
 453 static int gbaudio_tplg_create_enum_ctl(struct gbaudio_codec_info *gb,
 454                                         struct snd_kcontrol_new *kctl,
 455                                         struct gb_audio_control *ctl)
 456 {
 457         switch (ctl->id) {
 458         case 8:
 459                 *kctl = (struct snd_kcontrol_new)
 460                         SOC_DAPM_ENUM(ctl->name, gbcodec_apb1_rx_enum);
 461                 break;
 462         case 9:
 463                 *kctl = (struct snd_kcontrol_new)
 464                         SOC_DAPM_ENUM(ctl->name, gbcodec_mic_enum);
 465                 break;
 466         default:
 467                 return -EINVAL;
 468         }
 469
 470         return 0;
 471 }
 472
 473 static int gbaudio_tplg_create_mixer_ctl(struct gbaudio_codec_info *gb,
 474                                              struct snd_kcontrol_new *kctl,
 475                                              struct gb_audio_control *ctl)
 476 {
 477         struct gbaudio_ctl_pvt *ctldata;
 478
 479         ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),
 480                                GFP_KERNEL);
 481         if (!ctldata)
 482                 return -ENOMEM;
 483         ctldata->ctl_id = ctl->id;
 484         ctldata->data_cport = ctl->data_cport;
 485         ctldata->access = ctl->access;
 486         ctldata->vcount = ctl->count_values;
 487         ctldata->info = &ctl->info;
 488         *kctl = (struct snd_kcontrol_new)
 489                 SOC_DAPM_MIXER_GB(ctl->name, ctl->count, ctldata);
 490
 491         return 0;
 492 }
 493
 494 static int gbaudio_tplg_create_wcontrol(struct gbaudio_codec_info *gb,
 495                                              struct snd_kcontrol_new *kctl,
 496                                              struct gb_audio_control *ctl)
 497 {
 498         int ret;
 499
 500         switch (ctl->iface) {
 501         case SNDRV_CTL_ELEM_IFACE_MIXER:
 502                 switch (ctl->info.type) {
 503                 case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
 504                         ret = gbaudio_tplg_create_enum_ctl(gb, kctl, ctl);
 505                         break;
 506                 default:
 507                         ret = gbaudio_tplg_create_mixer_ctl(gb, kctl, ctl);
 508                         break;
 509                 }
 510                 break;
 511         default:
 512                 return -EINVAL;
 513
 514         }
 515
 516         dev_dbg(gb->dev, "%s:%d DAPM control created, ret:%d\n", ctl->name,
 517                 ctl->id, ret);
 518         return ret;
 519 }
 520
 521 static int gbaudio_widget_event(struct snd_soc_dapm_widget *w,
 522                                 struct snd_kcontrol *kcontrol, int event)
 523 {
 524         int wid;
 525         int ret;
 526         struct snd_soc_codec *codec = w->codec;
 527         struct gb_audio *audio = snd_soc_codec_get_drvdata(codec);
 528         struct gbaudio_codec_info *gbcodec = audio->gbcodec;
 529
 530         dev_dbg(codec->dev, "%s %s %d\n", __func__, w->name, event);
 531
 532         /* map name to widget id */
 533         wid = gbaudio_map_widgetname(gbcodec, w->name);
 534         if (wid < 0) {
 535                 dev_err(codec->dev, "Invalid widget name:%s\n", w->name);
 536                 return -EINVAL;
 537         }
 538
 539         switch (event) {
 540         case SND_SOC_DAPM_PRE_PMU:
 541                 ret = gb_audio_gb_enable_widget(gbcodec->mgmt_connection, wid);
 542                 break;
 543         case SND_SOC_DAPM_POST_PMD:
 544                 ret = gb_audio_gb_disable_widget(gbcodec->mgmt_connection, wid);
 545                 break;
 546         }
 547         if (ret)
 548                 dev_err(codec->dev, "%d: widget, event:%d failed:%d\n", wid,
 549                         event, ret);
 550         return ret;
 551 }
 552
 553 static int gbaudio_tplg_create_widget(struct gbaudio_codec_info *gbcodec,
 554                                       struct snd_soc_dapm_widget *dw,
 555                                       struct gb_audio_widget *w)
 556 {
 557         int i, ret;
 558         struct snd_kcontrol_new *widget_kctls;
 559         struct gb_audio_control *curr;
 560         struct gbaudio_control *control, *_control;
 561         size_t size;
 562
 563         ret = gbaudio_validate_kcontrol_count(w);
 564         if (ret) {
 565                 dev_err(gbcodec->dev, "Inavlid kcontrol count=%d for %s\n",
 566                         w->ncontrols, w->name);
 567                 return ret;
 568         }
 569
 570         /* allocate memory for kcontrol */
 571         if (w->ncontrols) {
 572                 size = sizeof(struct snd_kcontrol_new) * w->ncontrols;
 573                 widget_kctls = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
 574                 if (!widget_kctls)
 575                         return -ENOMEM;
 576         }
 577
 578         /* create relevant kcontrols */
 579         for (i = 0; i < w->ncontrols; i++) {
 580                 curr = &w->ctl[i];
 581                 ret = gbaudio_tplg_create_wcontrol(gbcodec, &widget_kctls[i],
 582                                                    curr);
 583                 if (ret) {
 584                         dev_err(gbcodec->dev,
 585                                 "%s:%d type widget_ctl not supported\n",
 586                                 curr->name, curr->iface);
 587                         goto error;
 588                 }
 589                 control = devm_kzalloc(gbcodec->dev,
 590                                        sizeof(struct gbaudio_control),
 591                                        GFP_KERNEL);
 592                 if (!control) {
 593                         ret = -ENOMEM;
 594                         goto error;
 595                 }
 596                 control->id = curr->id;
 597                 control->name = curr->name;
 598                 if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED)
 599                         control->texts = (const char * const *)
 600                                 curr->info.value.enumerated.names;
 601                 list_add(&control->list, &gbcodec->widget_ctl_list);
 602                 dev_dbg(gbcodec->dev, "%s: control of type %d created\n",
 603                         widget_kctls[i].name, widget_kctls[i].iface);
 604         }
 605
 606         switch (w->type) {
 607         case snd_soc_dapm_spk:
 608                 *dw = (struct snd_soc_dapm_widget)
 609                         SND_SOC_DAPM_SPK(w->name, gbcodec_event_spk);
 610                 break;
 611         case snd_soc_dapm_hp:
 612                 *dw = (struct snd_soc_dapm_widget)
 613                         SND_SOC_DAPM_HP(w->name, gbcodec_event_hp);
 614                 break;
 615         case snd_soc_dapm_mic:
 616                 *dw = (struct snd_soc_dapm_widget)
 617                         SND_SOC_DAPM_MIC(w->name, gbcodec_event_int_mic);
 618                 break;
 619         case snd_soc_dapm_output:
 620                 *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_OUTPUT(w->name);
 621                 break;
 622         case snd_soc_dapm_input:
 623                 *dw = (struct snd_soc_dapm_widget)SND_SOC_DAPM_INPUT(w->name);
 624                 break;
 625         case snd_soc_dapm_switch:
 626                 *dw = (struct snd_soc_dapm_widget)
 627                         SND_SOC_DAPM_SWITCH_E(w->name, SND_SOC_NOPM, 0, 0,
 628                                             widget_kctls, gbaudio_widget_event,
 629                                             SND_SOC_DAPM_PRE_PMU |
 630                                             SND_SOC_DAPM_POST_PMD);
 631                 break;
 632         case snd_soc_dapm_pga:
 633                 *dw = (struct snd_soc_dapm_widget)
 634                         SND_SOC_DAPM_PGA_E(w->name, SND_SOC_NOPM, 0, 0, NULL, 0,
 635                                            gbaudio_widget_event,
 636                                            SND_SOC_DAPM_PRE_PMU |
 637                                            SND_SOC_DAPM_POST_PMD);
 638                 break;
 639         case snd_soc_dapm_mixer:
 640                 *dw = (struct snd_soc_dapm_widget)
 641                         SND_SOC_DAPM_MIXER_E(w->name, SND_SOC_NOPM, 0, 0, NULL,
 642                                            0, gbaudio_widget_event,
 643                                            SND_SOC_DAPM_PRE_PMU |
 644                                            SND_SOC_DAPM_POST_PMD);
 645                 break;
 646         case snd_soc_dapm_mux:
 647                 *dw = (struct snd_soc_dapm_widget)
 648                         SND_SOC_DAPM_MUX_E(w->name, SND_SOC_NOPM, 0, 0,
 649                                          widget_kctls, gbaudio_widget_event,
 650                                          SND_SOC_DAPM_PRE_PMU |
 651                                          SND_SOC_DAPM_POST_PMD);
 652                 break;
 653         case snd_soc_dapm_aif_in:
 654                 *dw = (struct snd_soc_dapm_widget)
 655                         SND_SOC_DAPM_AIF_IN_E(w->name, w->sname, 0,
 656                                               SND_SOC_NOPM,
 657                                               0, 0, gbaudio_widget_event,
 658                                               SND_SOC_DAPM_PRE_PMU |
 659                                               SND_SOC_DAPM_POST_PMD);
 660                 break;
 661         case snd_soc_dapm_aif_out:
 662                 *dw = (struct snd_soc_dapm_widget)
 663                         SND_SOC_DAPM_AIF_OUT_E(w->name, w->sname, 0,
 664                                                SND_SOC_NOPM,
 665                                                0, 0, gbaudio_widget_event,
 666                                                SND_SOC_DAPM_PRE_PMU |
 667                                                SND_SOC_DAPM_POST_PMD);
 668                 break;
 669         default:
 670                 ret = -EINVAL;
 671                 goto error;
 672         }
 673
 674         dev_dbg(gbcodec->dev, "%s: widget of type %d created\n", dw->name,
 675                 dw->id);
 676         return 0;
 677 error:
 678         list_for_each_entry_safe(control, _control, &gbcodec->widget_ctl_list,
 679                                  list) {
 680                 list_del(&control->list);
 681                 devm_kfree(gbcodec->dev, control);
 682         }
 683         return ret;
 684 }
 685
 686 static int gbaudio_tplg_create_dai(struct gbaudio_codec_info *gbcodec,
 687                                    struct snd_soc_dai_driver *gb_dai,
 688                                    struct gb_audio_dai *dai)
 689 {
 690         /*
 691          * do not update name here,
 692          * append dev_id before assigning it here
 693          */
 694
 695         gb_dai->playback.stream_name = dai->playback.stream_name;
 696         gb_dai->playback.channels_min = dai->playback.chan_min;
 697         gb_dai->playback.channels_max = dai->playback.chan_max;
 698         gb_dai->playback.formats = dai->playback.formats;
 699         gb_dai->playback.rates = dai->playback.rates;
 700         gb_dai->playback.sig_bits = dai->playback.sig_bits;
 701
 702         gb_dai->capture.stream_name = dai->capture.stream_name;
 703         gb_dai->capture.channels_min = dai->capture.chan_min;
 704         gb_dai->capture.channels_max = dai->capture.chan_max;
 705         gb_dai->capture.formats = dai->capture.formats;
 706         gb_dai->capture.rates = dai->capture.rates;
 707         gb_dai->capture.sig_bits = dai->capture.sig_bits;
 708
 709         return 0;
 710 }
 711
 712 static int gbaudio_tplg_process_kcontrols(struct gbaudio_codec_info *gbcodec,
 713                                    struct gb_audio_control *controls)
 714 {
 715         int i, ret;
 716         struct snd_kcontrol_new *dapm_kctls;
 717         struct gb_audio_control *curr;
 718         struct gbaudio_control *control, *_control;
 719         size_t size;
 720
 721         size = sizeof(struct snd_kcontrol_new) * gbcodec->num_kcontrols;
 722         dapm_kctls = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
 723         if (!dapm_kctls)
 724                 return -ENOMEM;
 725
 726         curr = controls;
 727         for (i = 0; i < gbcodec->num_kcontrols; i++) {
 728                 ret = gbaudio_tplg_create_kcontrol(gbcodec, &dapm_kctls[i],
 729                                                    curr);
 730                 if (ret) {
 731                         dev_err(gbcodec->dev, "%s:%d type not supported\n",
 732                                 curr->name, curr->iface);
 733                         goto error;
 734                 }
 735                 control = devm_kzalloc(gbcodec->dev, sizeof(struct
 736                                                            gbaudio_control),
 737                                       GFP_KERNEL);
 738                 if (!control) {
 739                         ret = -ENOMEM;
 740                         goto error;
 741                 }
 742                 control->id = curr->id;
 743                 control->name = curr->name;
 744                 if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED)
 745                         control->texts = (const char * const *)
 746                                 curr->info.value.enumerated.names;
 747                 list_add(&control->list, &gbcodec->codec_ctl_list);
 748                 dev_dbg(gbcodec->dev, "%d:%s created of type %d\n", curr->id,
 749                         curr->name, curr->info.type);
 750                 curr++;
 751         }
 752         gbcodec->kctls = dapm_kctls;
 753
 754         return 0;
 755 error:
 756         list_for_each_entry_safe(control, _control, &gbcodec->codec_ctl_list,
 757                                  list) {
 758                 list_del(&control->list);
 759                 devm_kfree(gbcodec->dev, control);
 760         }
 761         devm_kfree(gbcodec->dev, dapm_kctls);
 762         return ret;
 763 }
 764
 765 static int gbaudio_tplg_process_widgets(struct gbaudio_codec_info *gbcodec,
 766                                    struct gb_audio_widget *widgets)
 767 {
 768         int i, ret, ncontrols;
 769         struct snd_soc_dapm_widget *dapm_widgets;
 770         struct gb_audio_widget *curr;
 771         struct gbaudio_widget *widget, *_widget;
 772         size_t size;
 773
 774         size = sizeof(struct snd_soc_dapm_widget) * gbcodec->num_dapm_widgets;
 775         dapm_widgets = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
 776         if (!dapm_widgets)
 777                 return -ENOMEM;
 778
 779         curr = widgets;
 780         for (i = 0; i < gbcodec->num_dapm_widgets; i++) {
 781                 ret = gbaudio_tplg_create_widget(gbcodec, &dapm_widgets[i],
 782                                                  curr);
 783                 if (ret) {
 784                         dev_err(gbcodec->dev, "%s:%d type not supported\n",
 785                                 curr->name, curr->type);
 786                         goto error;
 787                 }
 788                 widget = devm_kzalloc(gbcodec->dev, sizeof(struct
 789                                                            gbaudio_widget),
 790                                       GFP_KERNEL);
 791                 if (!widget) {
 792                         ret = -ENOMEM;
 793                         goto error;
 794                 }
 795                 widget->id = curr->id;
 796                 widget->name = curr->name;
 797                 list_add(&widget->list, &gbcodec->widget_list);
 798                 ncontrols = curr->ncontrols;
 799                 curr++;
 800                 curr += ncontrols * sizeof(struct gb_audio_control);
 801         }
 802         gbcodec->widgets = dapm_widgets;
 803
 804         return 0;
 805
 806 error:
 807         list_for_each_entry_safe(widget, _widget, &gbcodec->widget_list,
 808                                  list) {
 809                 list_del(&widget->list);
 810                 devm_kfree(gbcodec->dev, widget);
 811         }
 812         devm_kfree(gbcodec->dev, dapm_widgets);
 813         return ret;
 814 }
 815
 816 static int gbaudio_tplg_process_dais(struct gbaudio_codec_info *gbcodec,
 817                                    struct gb_audio_dai *dais)
 818 {
 819         int i, ret;
 820         struct snd_soc_dai_driver *gb_dais;
 821         struct gb_audio_dai *curr;
 822         struct gbaudio_dai *dai, *_dai;
 823         size_t size;
 824         char dai_name[NAME_SIZE];
 825
 826         size = sizeof(struct snd_soc_dai_driver) * gbcodec->num_dais;
 827         gb_dais = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
 828         if (!gb_dais)
 829                 return -ENOMEM;
 830
 831         curr = dais;
 832         for (i = 0; i < gbcodec->num_dais; i++) {
 833                 ret = gbaudio_tplg_create_dai(gbcodec, &gb_dais[i], curr);
 834                 if (ret) {
 835                         dev_err(gbcodec->dev, "%s failed to create\n",
 836                                 curr->name);
 837                         goto error;
 838                 }
 839                 /* append dev_id to dai_name */
 840                 snprintf(dai_name, NAME_SIZE, "%s.%d", curr->name,
 841                          gbcodec->dev_id);
 842                 dai = gbaudio_add_dai(gbcodec, curr->data_cport, NULL,
 843                                       dai_name);
 844                 if (!dai)
 845                         goto error;
 846                 dev_dbg(gbcodec->dev, "%s:DAI added\n", dai->name);
 847                 gb_dais[i].name = dai->name;
 848                 curr++;
 849         }
 850         gbcodec->dais = gb_dais;
 851
 852         return 0;
 853
 854 error:
 855         list_for_each_entry_safe(dai, _dai, &gbcodec->dai_list, list) {
 856                 list_del(&dai->list);
 857                 devm_kfree(gbcodec->dev, dai);
 858         }
 859         devm_kfree(gbcodec->dev, gb_dais);
 860         return ret;
 861 }
 862
 863 static int gbaudio_tplg_process_routes(struct gbaudio_codec_info *gbcodec,
 864                                    struct gb_audio_route *routes)
 865 {
 866         int i, ret;
 867         struct snd_soc_dapm_route *dapm_routes;
 868         struct gb_audio_route *curr;
 869         size_t size;
 870
 871         size = sizeof(struct snd_soc_dapm_route) * gbcodec->num_dapm_routes;
 872         dapm_routes = devm_kzalloc(gbcodec->dev, size, GFP_KERNEL);
 873         if (!dapm_routes)
 874                 return -ENOMEM;
 875
 876
 877         gbcodec->routes = dapm_routes;
 878         curr = routes;
 879
 880         for (i = 0; i < gbcodec->num_dapm_routes; i++) {
 881                 dapm_routes->sink =
 882                         gbaudio_map_widgetid(gbcodec, curr->destination_id);
 883                 if (!dapm_routes->sink) {
 884                         dev_err(gbcodec->dev, "%d:%d:%d:%d - Invalid sink\n",
 885                                 curr->source_id, curr->destination_id,
 886                                 curr->control_id, curr->index);
 887                         ret = -EINVAL;
 888                         goto error;
 889                 }
 890                 dapm_routes->source =
 891                         gbaudio_map_widgetid(gbcodec, curr->source_id);
 892                 if (!dapm_routes->source) {
 893                         dev_err(gbcodec->dev, "%d:%d:%d:%d - Invalid source\n",
 894                                 curr->source_id, curr->destination_id,
 895                                 curr->control_id, curr->index);
 896                         ret = -EINVAL;
 897                         goto error;
 898                 }
 899                 dapm_routes->control =
 900                         gbaudio_map_controlid(gbcodec,
 901                                                       curr->control_id,
 902                                                       curr->index);
 903                 if ((curr->control_id !=  GBAUDIO_INVALID_ID) &&
 904                     !dapm_routes->control) {
 905                         dev_err(gbcodec->dev, "%d:%d:%d:%d - Invalid control\n",
 906                                 curr->source_id, curr->destination_id,
 907                                 curr->control_id, curr->index);
 908                         ret = -EINVAL;
 909                         goto error;
 910                 }
 911                 dev_dbg(gbcodec->dev, "Route {%s, %s, %s}\n", dapm_routes->sink,
 912                         (dapm_routes->control) ? dapm_routes->control:"NULL",
 913                         dapm_routes->source);
 914                 dapm_routes++;
 915                 curr++;
 916         }
 917
 918         return 0;
 919
 920 error:
 921         devm_kfree(gbcodec->dev, dapm_routes);
 922         return ret;
 923 }
 924
 925 static int gbaudio_tplg_process_header(struct gbaudio_codec_info *gbcodec,
 926                                  struct gb_audio_topology *tplg_data)
 927 {
 928         /* fetch no. of kcontrols, widgets & routes */
 929         gbcodec->num_dais = tplg_data->num_dais;
 930         gbcodec->num_kcontrols = tplg_data->num_controls;
 931         gbcodec->num_dapm_widgets = tplg_data->num_widgets;
 932         gbcodec->num_dapm_routes = tplg_data->num_routes;
 933
 934         /* update block offset */
 935         gbcodec->dai_offset = (unsigned long)&tplg_data->data;
 936         gbcodec->control_offset = gbcodec->dai_offset + tplg_data->size_dais;
 937         gbcodec->widget_offset = gbcodec->control_offset +
 938                 tplg_data->size_controls;
 939         gbcodec->route_offset = gbcodec->widget_offset +
 940                 tplg_data->size_widgets;
 941
 942         dev_dbg(gbcodec->dev, "DAI offset is 0x%lx\n", gbcodec->dai_offset);
 943         dev_dbg(gbcodec->dev, "control offset is %lx\n",
 944                 gbcodec->control_offset);
 945         dev_dbg(gbcodec->dev, "widget offset is %lx\n", gbcodec->widget_offset);
 946         dev_dbg(gbcodec->dev, "route offset is %lx\n", gbcodec->route_offset);
 947
 948         return 0;
 949 }
 950
 951 static struct gbaudio_dai *gbaudio_allocate_dai(struct gbaudio_codec_info *gb,
 952                                          int data_cport,
 953                                          struct gb_connection *connection,
 954                                          const char *name)
 955 {
 956         struct gbaudio_dai *dai;
 957
 958         mutex_lock(&gb->lock);
 959         dai = devm_kzalloc(gb->dev, sizeof(*dai), GFP_KERNEL);
 960         if (!dai) {
 961                 dev_err(gb->dev, "%s:DAI Malloc failure\n", name);
 962                 mutex_unlock(&gb->lock);
 963                 return NULL;
 964         }
 965
 966         dai->data_cport = data_cport;
 967         dai->connection = connection;
 968
 969         /* update name */
 970         if (name)
 971                 strlcpy(dai->name, name, NAME_SIZE);
 972         list_add(&dai->list, &gb->dai_list);
 973         dev_dbg(gb->dev, "%d:%s: DAI added\n", data_cport, dai->name);
 974         mutex_unlock(&gb->lock);
 975
 976         return dai;
 977 }
 978
 979 struct gbaudio_dai *gbaudio_add_dai(struct gbaudio_codec_info *gbcodec,
 980                                     int data_cport,
 981                                     struct gb_connection *connection,
 982                                     const char *name)
 983 {
 984         struct gbaudio_dai *dai, *_dai;
 985
 986         /* FIXME need to take care for multiple DAIs */
 987         mutex_lock(&gbcodec->lock);
 988         if (list_empty(&gbcodec->dai_list)) {
 989                 mutex_unlock(&gbcodec->lock);
 990                 return gbaudio_allocate_dai(gbcodec, data_cport, connection,
 991                                             name);
 992         }
 993
 994         list_for_each_entry_safe(dai, _dai, &gbcodec->dai_list, list) {
 995                 if (dai->data_cport == data_cport) {
 996                         if (connection)
 997                                 dai->connection = connection;
 998
 999                         if (name)
1000                                 strlcpy(dai->name, name, NAME_SIZE);
1001                         dev_dbg(gbcodec->dev, "%d:%s: DAI updated\n",
1002                                 data_cport, dai->name);
1003                         mutex_unlock(&gbcodec->lock);
1004                         return dai;
1005                 }
1006         }
1007
1008         dev_err(gbcodec->dev, "%s:DAI not found\n", name);
1009         mutex_unlock(&gbcodec->lock);
1010         return NULL;
1011 }
1012
1013 int gbaudio_tplg_parse_data(struct gbaudio_codec_info *gbcodec,
1014                                struct gb_audio_topology *tplg_data)
1015 {
1016         int ret;
1017         struct gb_audio_dai *dais;
1018         struct gb_audio_control *controls;
1019         struct gb_audio_widget *widgets;
1020         struct gb_audio_route *routes;
1021
1022         if (!tplg_data)
1023                 return -EINVAL;
1024
1025         ret = gbaudio_tplg_process_header(gbcodec, tplg_data);
1026         if (ret) {
1027                 dev_err(gbcodec->dev, "%d: Error in parsing topology header\n",
1028                         ret);
1029                 return ret;
1030         }
1031
1032         /* process control */
1033         controls = (struct gb_audio_control *)gbcodec->control_offset;
1034         ret = gbaudio_tplg_process_kcontrols(gbcodec, controls);
1035         if (ret) {
1036                 dev_err(gbcodec->dev,
1037                         "%d: Error in parsing controls data\n", ret);
1038                 return ret;
1039         }
1040         dev_dbg(gbcodec->dev, "Control parsing finished\n");
1041
1042         /* process DAI */
1043         dais = (struct gb_audio_dai *)gbcodec->dai_offset;
1044         ret = gbaudio_tplg_process_dais(gbcodec, dais);
1045         if (ret) {
1046                 dev_err(gbcodec->dev,
1047                         "%d: Error in parsing DAIs data\n", ret);
1048                 return ret;
1049         }
1050         dev_dbg(gbcodec->dev, "DAI parsing finished\n");
1051
1052         /* process widgets */
1053         widgets = (struct gb_audio_widget *)gbcodec->widget_offset;
1054         ret = gbaudio_tplg_process_widgets(gbcodec, widgets);
1055         if (ret) {
1056                 dev_err(gbcodec->dev,
1057                         "%d: Error in parsing widgets data\n", ret);
1058                 return ret;
1059         }
1060         dev_dbg(gbcodec->dev, "Widget parsing finished\n");
1061
1062         /* process route */
1063         routes = (struct gb_audio_route *)gbcodec->route_offset;
1064         ret = gbaudio_tplg_process_routes(gbcodec, routes);
1065         if (ret) {
1066                 dev_err(gbcodec->dev,
1067                         "%d: Error in parsing routes data\n", ret);
1068                 return ret;
1069         }
1070         dev_dbg(gbcodec->dev, "Route parsing finished\n");
1071
1072         return ret;
1073 }
1074
1075 void gbaudio_tplg_release(struct gbaudio_codec_info *gbcodec)
1076 {
1077         struct gbaudio_dai *dai, *_dai;
1078         struct gbaudio_control *control, *_control;
1079         struct gbaudio_widget *widget, *_widget;
1080
1081         if (!gbcodec->topology)
1082                 return;
1083
1084         /* release kcontrols */
1085         list_for_each_entry_safe(control, _control, &gbcodec->codec_ctl_list,
1086                                  list) {
1087                 list_del(&control->list);
1088                 devm_kfree(gbcodec->dev, control);
1089         }
1090         if (gbcodec->kctls)
1091                 devm_kfree(gbcodec->dev, gbcodec->kctls);
1092
1093         /* release widget controls */
1094         list_for_each_entry_safe(control, _control, &gbcodec->widget_ctl_list,
1095                                  list) {
1096                 list_del(&control->list);
1097                 devm_kfree(gbcodec->dev, control);
1098         }
1099
1100         /* release widgets */
1101         list_for_each_entry_safe(widget, _widget, &gbcodec->widget_list,
1102                                  list) {
1103                 list_del(&widget->list);
1104                 devm_kfree(gbcodec->dev, widget);
1105         }
1106         if (gbcodec->widgets)
1107                 devm_kfree(gbcodec->dev, gbcodec->widgets);
1108
1109         /* release routes */
1110         if (gbcodec->routes)
1111                 devm_kfree(gbcodec->dev, gbcodec->routes);
1112
1113         /* release DAIs */
1114         mutex_lock(&gbcodec->lock);
1115         list_for_each_entry_safe(dai, _dai, &gbcodec->dai_list, list) {
1116                 list_del(&dai->list);
1117                 devm_kfree(gbcodec->dev, dai);
1118         }
1119         mutex_unlock(&gbcodec->lock);
1120 }