audio_topology.c

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