sdca_functions.c

   1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2// Copyright(c) 2024 Intel Corporation
   3
   4/*
   5 * The MIPI SDCA specification is available for public downloads at
   6 * https://www.mipi.org/mipi-sdca-v1-0-download
   7 */
   8
   9#include <linux/acpi.h>
  10#include <linux/byteorder/generic.h>
  11#include <linux/cleanup.h>
  12#include <linux/device.h>
  13#include <linux/dev_printk.h>
  14#include <linux/module.h>
  15#include <linux/property.h>
  16#include <linux/soundwire/sdw.h>
  17#include <linux/string.h>
  18#include <linux/types.h>
  19#include <sound/sdca.h>
  20#include <sound/sdca_function.h>
  21#include <sound/sdca_hid.h>
  22
  23/*
  24 * Should be long enough to encompass all the MIPI DisCo properties.
  25 */
  26#define SDCA_PROPERTY_LENGTH 64
  27
  28static int patch_sdca_function_type(u32 interface_revision, u32 *function_type)
  29{
  30	/*
  31	 * Unfortunately early SDCA specifications used different indices for Functions,
  32	 * for backwards compatibility we have to reorder the values found.
  33	 */
  34	if (interface_revision < 0x0801) {
  35		switch (*function_type) {
  36		case 1:
  37			*function_type = SDCA_FUNCTION_TYPE_SMART_AMP;
  38			break;
  39		case 2:
  40			*function_type = SDCA_FUNCTION_TYPE_SMART_MIC;
  41			break;
  42		case 3:
  43			*function_type = SDCA_FUNCTION_TYPE_SPEAKER_MIC;
  44			break;
  45		case 4:
  46			*function_type = SDCA_FUNCTION_TYPE_UAJ;
  47			break;
  48		case 5:
  49			*function_type = SDCA_FUNCTION_TYPE_RJ;
  50			break;
  51		case 6:
  52			*function_type = SDCA_FUNCTION_TYPE_HID;
  53			break;
  54		default:
  55			return -EINVAL;
  56		}
  57	}
  58
  59	return 0;
  60}
  61
  62static const char *get_sdca_function_name(u32 function_type)
  63{
  64	switch (function_type) {
  65	case SDCA_FUNCTION_TYPE_SMART_AMP:
  66		return SDCA_FUNCTION_TYPE_SMART_AMP_NAME;
  67	case SDCA_FUNCTION_TYPE_SMART_MIC:
  68		return SDCA_FUNCTION_TYPE_SMART_MIC_NAME;
  69	case SDCA_FUNCTION_TYPE_UAJ:
  70		return SDCA_FUNCTION_TYPE_UAJ_NAME;
  71	case SDCA_FUNCTION_TYPE_HID:
  72		return SDCA_FUNCTION_TYPE_HID_NAME;
  73	case SDCA_FUNCTION_TYPE_SIMPLE_AMP:
  74		return SDCA_FUNCTION_TYPE_SIMPLE_AMP_NAME;
  75	case SDCA_FUNCTION_TYPE_SIMPLE_MIC:
  76		return SDCA_FUNCTION_TYPE_SIMPLE_MIC_NAME;
  77	case SDCA_FUNCTION_TYPE_SPEAKER_MIC:
  78		return SDCA_FUNCTION_TYPE_SPEAKER_MIC_NAME;
  79	case SDCA_FUNCTION_TYPE_RJ:
  80		return SDCA_FUNCTION_TYPE_RJ_NAME;
  81	case SDCA_FUNCTION_TYPE_COMPANION_AMP:
  82		return SDCA_FUNCTION_TYPE_COMPANION_AMP_NAME;
  83	case SDCA_FUNCTION_TYPE_IMP_DEF:
  84		return SDCA_FUNCTION_TYPE_IMP_DEF_NAME;
  85	default:
  86		return NULL;
  87	}
  88}
  89
  90static int find_sdca_function(struct acpi_device *adev, void *data)
  91{
  92	struct fwnode_handle *function_node = acpi_fwnode_handle(adev);
  93	struct sdca_device_data *sdca_data = data;
  94	struct sdw_slave *slave = container_of(sdca_data, struct sdw_slave, sdca_data);
  95	struct device *dev = &adev->dev;
  96	struct fwnode_handle *control5; /* used to identify function type */
  97	const char *function_name;
  98	u32 function_type;
  99	int function_index;
 100	u64 addr;
 101	int ret;
 102
 103	if (sdca_data->num_functions >= SDCA_MAX_FUNCTION_COUNT) {
 104		dev_err(dev, "maximum number of functions exceeded\n");
 105		return -EINVAL;
 106	}
 107
 108	ret = acpi_get_local_u64_address(adev->handle, &addr);
 109	if (ret < 0)
 110		return ret;
 111
 112	if (!addr || addr > 0x7) {
 113		dev_err(dev, "invalid addr: 0x%llx\n", addr);
 114		return -ENODEV;
 115	}
 116
 117	/*
 118	 * Extracting the topology type for an SDCA function is a
 119	 * convoluted process.
 120	 * The Function type is only visible as a result of a read
 121	 * from a control. In theory this would mean reading from the hardware,
 122	 * but the SDCA/DisCo specs defined the notion of "DC value" - a constant
 123	 * represented with a DSD subproperty.
 124	 * Drivers have to query the properties for the control
 125	 * SDCA_CONTROL_ENTITY_0_FUNCTION_TOPOLOGY (0x05)
 126	 */
 127	control5 = fwnode_get_named_child_node(function_node,
 128					       "mipi-sdca-control-0x5-subproperties");
 129	if (!control5)
 130		return -ENODEV;
 131
 132	ret = fwnode_property_read_u32(control5, "mipi-sdca-control-dc-value",
 133				       &function_type);
 134
 135	fwnode_handle_put(control5);
 136
 137	if (ret < 0) {
 138		dev_err(dev, "function type only supported as DisCo constant\n");
 139		return ret;
 140	}
 141
 142	if (!sdca_device_quirk_match(slave, SDCA_QUIRKS_SKIP_FUNC_TYPE_PATCHING)) {
 143		ret = patch_sdca_function_type(sdca_data->interface_revision, &function_type);
 144		if (ret < 0) {
 145			dev_err(dev, "SDCA version %#x invalid function type %d\n",
 146				sdca_data->interface_revision, function_type);
 147			return ret;
 148		}
 149	}
 150
 151	function_name = get_sdca_function_name(function_type);
 152	if (!function_name) {
 153		dev_err(dev, "invalid SDCA function type %d\n", function_type);
 154		return -EINVAL;
 155	}
 156
 157	dev_info(dev, "SDCA function %s (type %d) at 0x%llx\n",
 158		 function_name, function_type, addr);
 159
 160	/* store results */
 161	function_index = sdca_data->num_functions;
 162	sdca_data->function[function_index].adr = addr;
 163	sdca_data->function[function_index].type = function_type;
 164	sdca_data->function[function_index].name = function_name;
 165	sdca_data->function[function_index].node = function_node;
 166	sdca_data->num_functions++;
 167
 168	return 0;
 169}
 170
 171/**
 172 * sdca_lookup_functions - Parse sdca_device_desc for each Function
 173 * @slave: SoundWire slave device to be processed.
 174 *
 175 * Iterate through the available SDCA Functions and fill in a short
 176 * descriptor (struct sdca_function_desc) for each function, this
 177 * information is stored along with the SoundWire slave device and
 178 * used for adding drivers and quirks before the devices have fully
 179 * probed.
 180 */
 181void sdca_lookup_functions(struct sdw_slave *slave)
 182{
 183	struct device *sdev = &slave->dev;
 184	struct acpi_device *adev = to_acpi_device_node(sdev->fwnode);
 185
 186	if (!adev) {
 187		dev_info(sdev, "no matching ACPI device found, ignoring peripheral\n");
 188		return;
 189	}
 190
 191	acpi_dev_for_each_child(adev, find_sdca_function, &slave->sdca_data);
 192}
 193EXPORT_SYMBOL_NS(sdca_lookup_functions, "SND_SOC_SDCA");
 194
 195struct raw_init_write {
 196	__le32 addr;
 197	u8 val;
 198} __packed;
 199
 200static int find_sdca_init_table(struct device *dev,
 201				struct fwnode_handle *function_node,
 202				struct sdca_function_data *function)
 203{
 204	struct raw_init_write *raw __free(kfree) = NULL;
 205	struct sdca_init_write *init_write;
 206	int i, num_init_writes;
 207
 208	num_init_writes = fwnode_property_count_u8(function_node,
 209						   "mipi-sdca-function-initialization-table");
 210	if (!num_init_writes || num_init_writes == -EINVAL) {
 211		return 0;
 212	} else if (num_init_writes < 0) {
 213		dev_err(dev, "%pfwP: failed to read initialization table: %d\n",
 214			function_node, num_init_writes);
 215		return num_init_writes;
 216	} else if (num_init_writes % sizeof(*raw) != 0) {
 217		dev_err(dev, "%pfwP: init table size invalid\n", function_node);
 218		return -EINVAL;
 219	} else if ((num_init_writes / sizeof(*raw)) > SDCA_MAX_INIT_COUNT) {
 220		dev_err(dev, "%pfwP: maximum init table size exceeded\n", function_node);
 221		return -EINVAL;
 222	}
 223
 224	raw = kzalloc(num_init_writes, GFP_KERNEL);
 225	if (!raw)
 226		return -ENOMEM;
 227
 228	fwnode_property_read_u8_array(function_node,
 229				      "mipi-sdca-function-initialization-table",
 230				      (u8 *)raw, num_init_writes);
 231
 232	num_init_writes /= sizeof(*raw);
 233
 234	init_write = devm_kcalloc(dev, num_init_writes, sizeof(*init_write), GFP_KERNEL);
 235	if (!init_write)
 236		return -ENOMEM;
 237
 238	for (i = 0; i < num_init_writes; i++) {
 239		init_write[i].addr = le32_to_cpu(raw[i].addr);
 240		init_write[i].val = raw[i].val;
 241	}
 242
 243	function->num_init_table = num_init_writes;
 244	function->init_table = init_write;
 245
 246	return 0;
 247}
 248
 249static const char *find_sdca_control_label(struct device *dev,
 250					   const struct sdca_entity *entity,
 251					   const struct sdca_control *control)
 252{
 253	switch (SDCA_CTL_TYPE(entity->type, control->sel)) {
 254	case SDCA_CTL_TYPE_S(IT, MIC_BIAS):
 255		return SDCA_CTL_MIC_BIAS_NAME;
 256	case SDCA_CTL_TYPE_S(IT, USAGE):
 257	case SDCA_CTL_TYPE_S(OT, USAGE):
 258		return SDCA_CTL_USAGE_NAME;
 259	case SDCA_CTL_TYPE_S(IT, LATENCY):
 260	case SDCA_CTL_TYPE_S(OT, LATENCY):
 261	case SDCA_CTL_TYPE_S(MU, LATENCY):
 262	case SDCA_CTL_TYPE_S(SU, LATENCY):
 263	case SDCA_CTL_TYPE_S(FU, LATENCY):
 264	case SDCA_CTL_TYPE_S(XU, LATENCY):
 265	case SDCA_CTL_TYPE_S(CRU, LATENCY):
 266	case SDCA_CTL_TYPE_S(UDMPU, LATENCY):
 267	case SDCA_CTL_TYPE_S(MFPU, LATENCY):
 268	case SDCA_CTL_TYPE_S(SMPU, LATENCY):
 269	case SDCA_CTL_TYPE_S(SAPU, LATENCY):
 270	case SDCA_CTL_TYPE_S(PPU, LATENCY):
 271		return SDCA_CTL_LATENCY_NAME;
 272	case SDCA_CTL_TYPE_S(IT, CLUSTERINDEX):
 273	case SDCA_CTL_TYPE_S(CRU, CLUSTERINDEX):
 274	case SDCA_CTL_TYPE_S(UDMPU, CLUSTERINDEX):
 275	case SDCA_CTL_TYPE_S(MFPU, CLUSTERINDEX):
 276		return SDCA_CTL_CLUSTERINDEX_NAME;
 277	case SDCA_CTL_TYPE_S(IT, DATAPORT_SELECTOR):
 278	case SDCA_CTL_TYPE_S(OT, DATAPORT_SELECTOR):
 279		return SDCA_CTL_DATAPORT_SELECTOR_NAME;
 280	case SDCA_CTL_TYPE_S(IT, MATCHING_GUID):
 281	case SDCA_CTL_TYPE_S(OT, MATCHING_GUID):
 282	case SDCA_CTL_TYPE_S(ENTITY_0, MATCHING_GUID):
 283		return SDCA_CTL_MATCHING_GUID_NAME;
 284	case SDCA_CTL_TYPE_S(IT, KEEP_ALIVE):
 285	case SDCA_CTL_TYPE_S(OT, KEEP_ALIVE):
 286		return SDCA_CTL_KEEP_ALIVE_NAME;
 287	case SDCA_CTL_TYPE_S(IT, NDAI_STREAM):
 288	case SDCA_CTL_TYPE_S(OT, NDAI_STREAM):
 289		return SDCA_CTL_NDAI_STREAM_NAME;
 290	case SDCA_CTL_TYPE_S(IT, NDAI_CATEGORY):
 291	case SDCA_CTL_TYPE_S(OT, NDAI_CATEGORY):
 292		return SDCA_CTL_NDAI_CATEGORY_NAME;
 293	case SDCA_CTL_TYPE_S(IT, NDAI_CODINGTYPE):
 294	case SDCA_CTL_TYPE_S(OT, NDAI_CODINGTYPE):
 295		return SDCA_CTL_NDAI_CODINGTYPE_NAME;
 296	case SDCA_CTL_TYPE_S(IT, NDAI_PACKETTYPE):
 297	case SDCA_CTL_TYPE_S(OT, NDAI_PACKETTYPE):
 298		return SDCA_CTL_NDAI_PACKETTYPE_NAME;
 299	case SDCA_CTL_TYPE_S(MU, MIXER):
 300		return SDCA_CTL_MIXER_NAME;
 301	case SDCA_CTL_TYPE_S(SU, SELECTOR):
 302		return SDCA_CTL_SELECTOR_NAME;
 303	case SDCA_CTL_TYPE_S(FU, MUTE):
 304		return SDCA_CTL_MUTE_NAME;
 305	case SDCA_CTL_TYPE_S(FU, CHANNEL_VOLUME):
 306		return SDCA_CTL_CHANNEL_VOLUME_NAME;
 307	case SDCA_CTL_TYPE_S(FU, AGC):
 308		return SDCA_CTL_AGC_NAME;
 309	case SDCA_CTL_TYPE_S(FU, BASS_BOOST):
 310		return SDCA_CTL_BASS_BOOST_NAME;
 311	case SDCA_CTL_TYPE_S(FU, LOUDNESS):
 312		return SDCA_CTL_LOUDNESS_NAME;
 313	case SDCA_CTL_TYPE_S(FU, GAIN):
 314		return SDCA_CTL_GAIN_NAME;
 315	case SDCA_CTL_TYPE_S(XU, BYPASS):
 316	case SDCA_CTL_TYPE_S(MFPU, BYPASS):
 317		return SDCA_CTL_BYPASS_NAME;
 318	case SDCA_CTL_TYPE_S(XU, XU_ID):
 319		return SDCA_CTL_XU_ID_NAME;
 320	case SDCA_CTL_TYPE_S(XU, XU_VERSION):
 321		return SDCA_CTL_XU_VERSION_NAME;
 322	case SDCA_CTL_TYPE_S(XU, FDL_CURRENTOWNER):
 323		return SDCA_CTL_FDL_CURRENTOWNER_NAME;
 324	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGEOFFSET):
 325		return SDCA_CTL_FDL_MESSAGEOFFSET_NAME;
 326	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGELENGTH):
 327		return SDCA_CTL_FDL_MESSAGELENGTH_NAME;
 328	case SDCA_CTL_TYPE_S(XU, FDL_STATUS):
 329		return SDCA_CTL_FDL_STATUS_NAME;
 330	case SDCA_CTL_TYPE_S(XU, FDL_SET_INDEX):
 331		return SDCA_CTL_FDL_SET_INDEX_NAME;
 332	case SDCA_CTL_TYPE_S(XU, FDL_HOST_REQUEST):
 333		return SDCA_CTL_FDL_HOST_REQUEST_NAME;
 334	case SDCA_CTL_TYPE_S(CS, CLOCK_VALID):
 335		return SDCA_CTL_CLOCK_VALID_NAME;
 336	case SDCA_CTL_TYPE_S(CS, SAMPLERATEINDEX):
 337		return SDCA_CTL_SAMPLERATEINDEX_NAME;
 338	case SDCA_CTL_TYPE_S(CX, CLOCK_SELECT):
 339		return SDCA_CTL_CLOCK_SELECT_NAME;
 340	case SDCA_CTL_TYPE_S(PDE, REQUESTED_PS):
 341		return SDCA_CTL_REQUESTED_PS_NAME;
 342	case SDCA_CTL_TYPE_S(PDE, ACTUAL_PS):
 343		return SDCA_CTL_ACTUAL_PS_NAME;
 344	case SDCA_CTL_TYPE_S(GE, SELECTED_MODE):
 345		return SDCA_CTL_SELECTED_MODE_NAME;
 346	case SDCA_CTL_TYPE_S(GE, DETECTED_MODE):
 347		return SDCA_CTL_DETECTED_MODE_NAME;
 348	case SDCA_CTL_TYPE_S(SPE, PRIVATE):
 349		return SDCA_CTL_PRIVATE_NAME;
 350	case SDCA_CTL_TYPE_S(SPE, PRIVACY_POLICY):
 351		return SDCA_CTL_PRIVACY_POLICY_NAME;
 352	case SDCA_CTL_TYPE_S(SPE, PRIVACY_LOCKSTATE):
 353		return SDCA_CTL_PRIVACY_LOCKSTATE_NAME;
 354	case SDCA_CTL_TYPE_S(SPE, PRIVACY_OWNER):
 355		return SDCA_CTL_PRIVACY_OWNER_NAME;
 356	case SDCA_CTL_TYPE_S(SPE, AUTHTX_CURRENTOWNER):
 357		return SDCA_CTL_AUTHTX_CURRENTOWNER_NAME;
 358	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGEOFFSET):
 359		return SDCA_CTL_AUTHTX_MESSAGEOFFSET_NAME;
 360	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGELENGTH):
 361		return SDCA_CTL_AUTHTX_MESSAGELENGTH_NAME;
 362	case SDCA_CTL_TYPE_S(SPE, AUTHRX_CURRENTOWNER):
 363		return SDCA_CTL_AUTHRX_CURRENTOWNER_NAME;
 364	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGEOFFSET):
 365		return SDCA_CTL_AUTHRX_MESSAGEOFFSET_NAME;
 366	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGELENGTH):
 367		return SDCA_CTL_AUTHRX_MESSAGELENGTH_NAME;
 368	case SDCA_CTL_TYPE_S(UDMPU, ACOUSTIC_ENERGY_LEVEL_MONITOR):
 369		return SDCA_CTL_ACOUSTIC_ENERGY_LEVEL_MONITOR_NAME;
 370	case SDCA_CTL_TYPE_S(UDMPU, ULTRASOUND_LOOP_GAIN):
 371		return SDCA_CTL_ULTRASOUND_LOOP_GAIN_NAME;
 372	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_0):
 373		return SDCA_CTL_OPAQUESET_0_NAME;
 374	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_1):
 375		return SDCA_CTL_OPAQUESET_1_NAME;
 376	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_2):
 377		return SDCA_CTL_OPAQUESET_2_NAME;
 378	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_3):
 379		return SDCA_CTL_OPAQUESET_3_NAME;
 380	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_4):
 381		return SDCA_CTL_OPAQUESET_4_NAME;
 382	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_5):
 383		return SDCA_CTL_OPAQUESET_5_NAME;
 384	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_6):
 385		return SDCA_CTL_OPAQUESET_6_NAME;
 386	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_7):
 387		return SDCA_CTL_OPAQUESET_7_NAME;
 388	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_8):
 389		return SDCA_CTL_OPAQUESET_8_NAME;
 390	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_9):
 391		return SDCA_CTL_OPAQUESET_9_NAME;
 392	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_10):
 393		return SDCA_CTL_OPAQUESET_10_NAME;
 394	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_11):
 395		return SDCA_CTL_OPAQUESET_11_NAME;
 396	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_12):
 397		return SDCA_CTL_OPAQUESET_12_NAME;
 398	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_13):
 399		return SDCA_CTL_OPAQUESET_13_NAME;
 400	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_14):
 401		return SDCA_CTL_OPAQUESET_14_NAME;
 402	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_15):
 403		return SDCA_CTL_OPAQUESET_15_NAME;
 404	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_16):
 405		return SDCA_CTL_OPAQUESET_16_NAME;
 406	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_17):
 407		return SDCA_CTL_OPAQUESET_17_NAME;
 408	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_18):
 409		return SDCA_CTL_OPAQUESET_18_NAME;
 410	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_19):
 411		return SDCA_CTL_OPAQUESET_19_NAME;
 412	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_20):
 413		return SDCA_CTL_OPAQUESET_20_NAME;
 414	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_21):
 415		return SDCA_CTL_OPAQUESET_21_NAME;
 416	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_22):
 417		return SDCA_CTL_OPAQUESET_22_NAME;
 418	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_23):
 419		return SDCA_CTL_OPAQUESET_23_NAME;
 420	case SDCA_CTL_TYPE_S(MFPU, ALGORITHM_READY):
 421		return SDCA_CTL_ALGORITHM_READY_NAME;
 422	case SDCA_CTL_TYPE_S(MFPU, ALGORITHM_ENABLE):
 423		return SDCA_CTL_ALGORITHM_ENABLE_NAME;
 424	case SDCA_CTL_TYPE_S(MFPU, ALGORITHM_PREPARE):
 425		return SDCA_CTL_ALGORITHM_PREPARE_NAME;
 426	case SDCA_CTL_TYPE_S(MFPU, CENTER_FREQUENCY_INDEX):
 427		return SDCA_CTL_CENTER_FREQUENCY_INDEX_NAME;
 428	case SDCA_CTL_TYPE_S(MFPU, ULTRASOUND_LEVEL):
 429		return SDCA_CTL_ULTRASOUND_LEVEL_NAME;
 430	case SDCA_CTL_TYPE_S(MFPU, AE_NUMBER):
 431		return SDCA_CTL_AE_NUMBER_NAME;
 432	case SDCA_CTL_TYPE_S(MFPU, AE_CURRENTOWNER):
 433		return SDCA_CTL_AE_CURRENTOWNER_NAME;
 434	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGEOFFSET):
 435		return SDCA_CTL_AE_MESSAGEOFFSET_NAME;
 436	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGELENGTH):
 437		return SDCA_CTL_AE_MESSAGELENGTH_NAME;
 438	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_ENABLE):
 439		return SDCA_CTL_TRIGGER_ENABLE_NAME;
 440	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_STATUS):
 441		return SDCA_CTL_TRIGGER_STATUS_NAME;
 442	case SDCA_CTL_TYPE_S(SMPU, HIST_BUFFER_MODE):
 443		return SDCA_CTL_HIST_BUFFER_MODE_NAME;
 444	case SDCA_CTL_TYPE_S(SMPU, HIST_BUFFER_PREAMBLE):
 445		return SDCA_CTL_HIST_BUFFER_PREAMBLE_NAME;
 446	case SDCA_CTL_TYPE_S(SMPU, HIST_ERROR):
 447		return SDCA_CTL_HIST_ERROR_NAME;
 448	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_EXTENSION):
 449		return SDCA_CTL_TRIGGER_EXTENSION_NAME;
 450	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_READY):
 451		return SDCA_CTL_TRIGGER_READY_NAME;
 452	case SDCA_CTL_TYPE_S(SMPU, HIST_CURRENTOWNER):
 453		return SDCA_CTL_HIST_CURRENTOWNER_NAME;
 454	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGEOFFSET):
 455		return SDCA_CTL_HIST_MESSAGEOFFSET_NAME;
 456	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGELENGTH):
 457		return SDCA_CTL_HIST_MESSAGELENGTH_NAME;
 458	case SDCA_CTL_TYPE_S(SMPU, DTODTX_CURRENTOWNER):
 459		return SDCA_CTL_DTODTX_CURRENTOWNER_NAME;
 460	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGEOFFSET):
 461		return SDCA_CTL_DTODTX_MESSAGEOFFSET_NAME;
 462	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGELENGTH):
 463		return SDCA_CTL_DTODTX_MESSAGELENGTH_NAME;
 464	case SDCA_CTL_TYPE_S(SMPU, DTODRX_CURRENTOWNER):
 465		return SDCA_CTL_DTODRX_CURRENTOWNER_NAME;
 466	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGEOFFSET):
 467		return SDCA_CTL_DTODRX_MESSAGEOFFSET_NAME;
 468	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGELENGTH):
 469		return SDCA_CTL_DTODRX_MESSAGELENGTH_NAME;
 470	case SDCA_CTL_TYPE_S(SAPU, PROTECTION_MODE):
 471		return SDCA_CTL_PROTECTION_MODE_NAME;
 472	case SDCA_CTL_TYPE_S(SAPU, PROTECTION_STATUS):
 473		return SDCA_CTL_PROTECTION_STATUS_NAME;
 474	case SDCA_CTL_TYPE_S(SAPU, OPAQUESETREQ_INDEX):
 475		return SDCA_CTL_OPAQUESETREQ_INDEX_NAME;
 476	case SDCA_CTL_TYPE_S(SAPU, DTODTX_CURRENTOWNER):
 477		return SDCA_CTL_DTODTX_CURRENTOWNER_NAME;
 478	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGEOFFSET):
 479		return SDCA_CTL_DTODTX_MESSAGEOFFSET_NAME;
 480	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGELENGTH):
 481		return SDCA_CTL_DTODTX_MESSAGELENGTH_NAME;
 482	case SDCA_CTL_TYPE_S(SAPU, DTODRX_CURRENTOWNER):
 483		return SDCA_CTL_DTODRX_CURRENTOWNER_NAME;
 484	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGEOFFSET):
 485		return SDCA_CTL_DTODRX_MESSAGEOFFSET_NAME;
 486	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGELENGTH):
 487		return SDCA_CTL_DTODRX_MESSAGELENGTH_NAME;
 488	case SDCA_CTL_TYPE_S(PPU, POSTURENUMBER):
 489		return SDCA_CTL_POSTURENUMBER_NAME;
 490	case SDCA_CTL_TYPE_S(PPU, POSTUREEXTENSION):
 491		return SDCA_CTL_POSTUREEXTENSION_NAME;
 492	case SDCA_CTL_TYPE_S(PPU, HORIZONTALBALANCE):
 493		return SDCA_CTL_HORIZONTALBALANCE_NAME;
 494	case SDCA_CTL_TYPE_S(PPU, VERTICALBALANCE):
 495		return SDCA_CTL_VERTICALBALANCE_NAME;
 496	case SDCA_CTL_TYPE_S(TG, TONE_DIVIDER):
 497		return SDCA_CTL_TONE_DIVIDER_NAME;
 498	case SDCA_CTL_TYPE_S(HIDE, HIDTX_CURRENTOWNER):
 499		return SDCA_CTL_HIDTX_CURRENTOWNER_NAME;
 500	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGEOFFSET):
 501		return SDCA_CTL_HIDTX_MESSAGEOFFSET_NAME;
 502	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGELENGTH):
 503		return SDCA_CTL_HIDTX_MESSAGELENGTH_NAME;
 504	case SDCA_CTL_TYPE_S(HIDE, HIDRX_CURRENTOWNER):
 505		return SDCA_CTL_HIDRX_CURRENTOWNER_NAME;
 506	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGEOFFSET):
 507		return SDCA_CTL_HIDRX_MESSAGEOFFSET_NAME;
 508	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGELENGTH):
 509		return SDCA_CTL_HIDRX_MESSAGELENGTH_NAME;
 510	case SDCA_CTL_TYPE_S(ENTITY_0, COMMIT_GROUP_MASK):
 511		return SDCA_CTL_COMMIT_GROUP_MASK_NAME;
 512	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_SDCA_VERSION):
 513		return SDCA_CTL_FUNCTION_SDCA_VERSION_NAME;
 514	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_TYPE):
 515		return SDCA_CTL_FUNCTION_TYPE_NAME;
 516	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_MANUFACTURER_ID):
 517		return SDCA_CTL_FUNCTION_MANUFACTURER_ID_NAME;
 518	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_ID):
 519		return SDCA_CTL_FUNCTION_ID_NAME;
 520	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_VERSION):
 521		return SDCA_CTL_FUNCTION_VERSION_NAME;
 522	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_EXTENSION_ID):
 523		return SDCA_CTL_FUNCTION_EXTENSION_ID_NAME;
 524	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_EXTENSION_VERSION):
 525		return SDCA_CTL_FUNCTION_EXTENSION_VERSION_NAME;
 526	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_STATUS):
 527		return SDCA_CTL_FUNCTION_STATUS_NAME;
 528	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_ACTION):
 529		return SDCA_CTL_FUNCTION_ACTION_NAME;
 530	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_MANUFACTURER_ID):
 531		return SDCA_CTL_DEVICE_MANUFACTURER_ID_NAME;
 532	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_PART_ID):
 533		return SDCA_CTL_DEVICE_PART_ID_NAME;
 534	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_VERSION):
 535		return SDCA_CTL_DEVICE_VERSION_NAME;
 536	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_SDCA_VERSION):
 537		return SDCA_CTL_DEVICE_SDCA_VERSION_NAME;
 538	default:
 539		return devm_kasprintf(dev, GFP_KERNEL, "Imp-Def %#x", control->sel);
 540	}
 541}
 542
 543static unsigned int find_sdca_control_bits(const struct sdca_entity *entity,
 544					   const struct sdca_control *control)
 545{
 546	switch (SDCA_CTL_TYPE(entity->type, control->sel)) {
 547	case SDCA_CTL_TYPE_S(IT, LATENCY):
 548	case SDCA_CTL_TYPE_S(OT, LATENCY):
 549	case SDCA_CTL_TYPE_S(MU, LATENCY):
 550	case SDCA_CTL_TYPE_S(SU, LATENCY):
 551	case SDCA_CTL_TYPE_S(FU, LATENCY):
 552	case SDCA_CTL_TYPE_S(XU, LATENCY):
 553	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGEOFFSET):
 554	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGELENGTH):
 555	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGEOFFSET):
 556	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGELENGTH):
 557	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGEOFFSET):
 558	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGELENGTH):
 559	case SDCA_CTL_TYPE_S(CRU, LATENCY):
 560	case SDCA_CTL_TYPE_S(UDMPU, LATENCY):
 561	case SDCA_CTL_TYPE_S(MFPU, LATENCY):
 562	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGEOFFSET):
 563	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGELENGTH):
 564	case SDCA_CTL_TYPE_S(SMPU, LATENCY):
 565	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGEOFFSET):
 566	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGELENGTH):
 567	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGEOFFSET):
 568	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGELENGTH):
 569	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGEOFFSET):
 570	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGELENGTH):
 571	case SDCA_CTL_TYPE_S(SAPU, LATENCY):
 572	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGEOFFSET):
 573	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGELENGTH):
 574	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGEOFFSET):
 575	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGELENGTH):
 576	case SDCA_CTL_TYPE_S(PPU, LATENCY):
 577	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGEOFFSET):
 578	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGELENGTH):
 579	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGEOFFSET):
 580	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGELENGTH):
 581		return 32;
 582	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_MANUFACTURER_ID):
 583	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_ID):
 584	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_EXTENSION_ID):
 585	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_MANUFACTURER_ID):
 586	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_PART_ID):
 587	case SDCA_CTL_TYPE_S(IT, DATAPORT_SELECTOR):
 588	case SDCA_CTL_TYPE_S(OT, DATAPORT_SELECTOR):
 589	case SDCA_CTL_TYPE_S(MU, MIXER):
 590	case SDCA_CTL_TYPE_S(FU, CHANNEL_VOLUME):
 591	case SDCA_CTL_TYPE_S(FU, GAIN):
 592	case SDCA_CTL_TYPE_S(XU, XU_ID):
 593	case SDCA_CTL_TYPE_S(UDMPU, ACOUSTIC_ENERGY_LEVEL_MONITOR):
 594	case SDCA_CTL_TYPE_S(UDMPU, ULTRASOUND_LOOP_GAIN):
 595	case SDCA_CTL_TYPE_S(MFPU, ULTRASOUND_LEVEL):
 596	case SDCA_CTL_TYPE_S(PPU, HORIZONTALBALANCE):
 597	case SDCA_CTL_TYPE_S(PPU, VERTICALBALANCE):
 598		return 16;
 599	case SDCA_CTL_TYPE_S(FU, MUTE):
 600	case SDCA_CTL_TYPE_S(FU, AGC):
 601	case SDCA_CTL_TYPE_S(FU, BASS_BOOST):
 602	case SDCA_CTL_TYPE_S(FU, LOUDNESS):
 603	case SDCA_CTL_TYPE_S(XU, BYPASS):
 604	case SDCA_CTL_TYPE_S(MFPU, BYPASS):
 605		return 1;
 606	default:
 607		return 8;
 608	}
 609}
 610
 611static enum sdca_control_datatype
 612find_sdca_control_datatype(const struct sdca_entity *entity,
 613			   const struct sdca_control *control)
 614{
 615	switch (SDCA_CTL_TYPE(entity->type, control->sel)) {
 616	case SDCA_CTL_TYPE_S(XU, BYPASS):
 617	case SDCA_CTL_TYPE_S(MFPU, BYPASS):
 618	case SDCA_CTL_TYPE_S(FU, MUTE):
 619	case SDCA_CTL_TYPE_S(FU, AGC):
 620	case SDCA_CTL_TYPE_S(FU, BASS_BOOST):
 621	case SDCA_CTL_TYPE_S(FU, LOUDNESS):
 622		return SDCA_CTL_DATATYPE_ONEBIT;
 623	case SDCA_CTL_TYPE_S(IT, LATENCY):
 624	case SDCA_CTL_TYPE_S(OT, LATENCY):
 625	case SDCA_CTL_TYPE_S(MU, LATENCY):
 626	case SDCA_CTL_TYPE_S(SU, LATENCY):
 627	case SDCA_CTL_TYPE_S(FU, LATENCY):
 628	case SDCA_CTL_TYPE_S(XU, LATENCY):
 629	case SDCA_CTL_TYPE_S(CRU, LATENCY):
 630	case SDCA_CTL_TYPE_S(UDMPU, LATENCY):
 631	case SDCA_CTL_TYPE_S(MFPU, LATENCY):
 632	case SDCA_CTL_TYPE_S(SMPU, LATENCY):
 633	case SDCA_CTL_TYPE_S(SAPU, LATENCY):
 634	case SDCA_CTL_TYPE_S(PPU, LATENCY):
 635	case SDCA_CTL_TYPE_S(SU, SELECTOR):
 636	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_0):
 637	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_1):
 638	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_2):
 639	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_3):
 640	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_4):
 641	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_5):
 642	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_6):
 643	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_7):
 644	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_8):
 645	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_9):
 646	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_10):
 647	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_11):
 648	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_12):
 649	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_13):
 650	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_14):
 651	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_15):
 652	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_16):
 653	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_17):
 654	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_18):
 655	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_19):
 656	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_20):
 657	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_21):
 658	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_22):
 659	case SDCA_CTL_TYPE_S(UDMPU, OPAQUESET_23):
 660	case SDCA_CTL_TYPE_S(SAPU, PROTECTION_MODE):
 661	case SDCA_CTL_TYPE_S(SMPU, HIST_BUFFER_PREAMBLE):
 662	case SDCA_CTL_TYPE_S(XU, FDL_HOST_REQUEST):
 663	case SDCA_CTL_TYPE_S(XU, XU_ID):
 664	case SDCA_CTL_TYPE_S(CX, CLOCK_SELECT):
 665	case SDCA_CTL_TYPE_S(TG, TONE_DIVIDER):
 666	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_MANUFACTURER_ID):
 667	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_ID):
 668	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_EXTENSION_ID):
 669	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_MANUFACTURER_ID):
 670	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_PART_ID):
 671	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGEOFFSET):
 672	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGELENGTH):
 673	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGEOFFSET):
 674	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGELENGTH):
 675	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGEOFFSET):
 676	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGELENGTH):
 677	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGEOFFSET):
 678	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGELENGTH):
 679	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGEOFFSET):
 680	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGELENGTH):
 681	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGEOFFSET):
 682	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGELENGTH):
 683	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGEOFFSET):
 684	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGELENGTH):
 685	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGEOFFSET):
 686	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGELENGTH):
 687	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGEOFFSET):
 688	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGELENGTH):
 689	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGEOFFSET):
 690	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGELENGTH):
 691	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGEOFFSET):
 692	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGELENGTH):
 693		return SDCA_CTL_DATATYPE_INTEGER;
 694	case SDCA_CTL_TYPE_S(IT, MIC_BIAS):
 695	case SDCA_CTL_TYPE_S(SMPU, HIST_BUFFER_MODE):
 696	case SDCA_CTL_TYPE_S(PDE, REQUESTED_PS):
 697	case SDCA_CTL_TYPE_S(PDE, ACTUAL_PS):
 698	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_TYPE):
 699		return SDCA_CTL_DATATYPE_SPEC_ENCODED_VALUE;
 700	case SDCA_CTL_TYPE_S(XU, XU_VERSION):
 701	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_SDCA_VERSION):
 702	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_VERSION):
 703	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_EXTENSION_VERSION):
 704	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_VERSION):
 705	case SDCA_CTL_TYPE_S(ENTITY_0, DEVICE_SDCA_VERSION):
 706		return SDCA_CTL_DATATYPE_BCD;
 707	case SDCA_CTL_TYPE_S(FU, CHANNEL_VOLUME):
 708	case SDCA_CTL_TYPE_S(FU, GAIN):
 709	case SDCA_CTL_TYPE_S(MU, MIXER):
 710	case SDCA_CTL_TYPE_S(PPU, HORIZONTALBALANCE):
 711	case SDCA_CTL_TYPE_S(PPU, VERTICALBALANCE):
 712	case SDCA_CTL_TYPE_S(MFPU, ULTRASOUND_LEVEL):
 713	case SDCA_CTL_TYPE_S(UDMPU, ACOUSTIC_ENERGY_LEVEL_MONITOR):
 714	case SDCA_CTL_TYPE_S(UDMPU, ULTRASOUND_LOOP_GAIN):
 715		return SDCA_CTL_DATATYPE_Q7P8DB;
 716	case SDCA_CTL_TYPE_S(IT, USAGE):
 717	case SDCA_CTL_TYPE_S(OT, USAGE):
 718	case SDCA_CTL_TYPE_S(IT, CLUSTERINDEX):
 719	case SDCA_CTL_TYPE_S(CRU, CLUSTERINDEX):
 720	case SDCA_CTL_TYPE_S(UDMPU, CLUSTERINDEX):
 721	case SDCA_CTL_TYPE_S(MFPU, CLUSTERINDEX):
 722	case SDCA_CTL_TYPE_S(MFPU, CENTER_FREQUENCY_INDEX):
 723	case SDCA_CTL_TYPE_S(MFPU, AE_NUMBER):
 724	case SDCA_CTL_TYPE_S(SAPU, OPAQUESETREQ_INDEX):
 725	case SDCA_CTL_TYPE_S(XU, FDL_SET_INDEX):
 726	case SDCA_CTL_TYPE_S(CS, SAMPLERATEINDEX):
 727	case SDCA_CTL_TYPE_S(GE, SELECTED_MODE):
 728	case SDCA_CTL_TYPE_S(GE, DETECTED_MODE):
 729		return SDCA_CTL_DATATYPE_BYTEINDEX;
 730	case SDCA_CTL_TYPE_S(PPU, POSTURENUMBER):
 731		return SDCA_CTL_DATATYPE_POSTURENUMBER;
 732	case SDCA_CTL_TYPE_S(IT, DATAPORT_SELECTOR):
 733	case SDCA_CTL_TYPE_S(OT, DATAPORT_SELECTOR):
 734		return SDCA_CTL_DATATYPE_DP_INDEX;
 735	case SDCA_CTL_TYPE_S(MFPU, ALGORITHM_READY):
 736	case SDCA_CTL_TYPE_S(MFPU, ALGORITHM_ENABLE):
 737	case SDCA_CTL_TYPE_S(MFPU, ALGORITHM_PREPARE):
 738	case SDCA_CTL_TYPE_S(SAPU, PROTECTION_STATUS):
 739	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_ENABLE):
 740	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_STATUS):
 741	case SDCA_CTL_TYPE_S(SMPU, TRIGGER_READY):
 742	case SDCA_CTL_TYPE_S(SPE, PRIVACY_POLICY):
 743	case SDCA_CTL_TYPE_S(SPE, PRIVACY_OWNER):
 744		return SDCA_CTL_DATATYPE_BITINDEX;
 745	case SDCA_CTL_TYPE_S(IT, KEEP_ALIVE):
 746	case SDCA_CTL_TYPE_S(OT, KEEP_ALIVE):
 747	case SDCA_CTL_TYPE_S(IT, NDAI_STREAM):
 748	case SDCA_CTL_TYPE_S(OT, NDAI_STREAM):
 749	case SDCA_CTL_TYPE_S(IT, NDAI_CATEGORY):
 750	case SDCA_CTL_TYPE_S(OT, NDAI_CATEGORY):
 751	case SDCA_CTL_TYPE_S(IT, NDAI_CODINGTYPE):
 752	case SDCA_CTL_TYPE_S(OT, NDAI_CODINGTYPE):
 753	case SDCA_CTL_TYPE_S(IT, NDAI_PACKETTYPE):
 754	case SDCA_CTL_TYPE_S(OT, NDAI_PACKETTYPE):
 755	case SDCA_CTL_TYPE_S(SMPU, HIST_ERROR):
 756	case SDCA_CTL_TYPE_S(XU, FDL_STATUS):
 757	case SDCA_CTL_TYPE_S(CS, CLOCK_VALID):
 758	case SDCA_CTL_TYPE_S(SPE, PRIVACY_LOCKSTATE):
 759	case SDCA_CTL_TYPE_S(ENTITY_0, COMMIT_GROUP_MASK):
 760	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_STATUS):
 761	case SDCA_CTL_TYPE_S(ENTITY_0, FUNCTION_ACTION):
 762	case SDCA_CTL_TYPE_S(XU, FDL_CURRENTOWNER):
 763	case SDCA_CTL_TYPE_S(SPE, AUTHTX_CURRENTOWNER):
 764	case SDCA_CTL_TYPE_S(SPE, AUTHRX_CURRENTOWNER):
 765	case SDCA_CTL_TYPE_S(MFPU, AE_CURRENTOWNER):
 766	case SDCA_CTL_TYPE_S(SMPU, HIST_CURRENTOWNER):
 767	case SDCA_CTL_TYPE_S(SMPU, DTODTX_CURRENTOWNER):
 768	case SDCA_CTL_TYPE_S(SMPU, DTODRX_CURRENTOWNER):
 769	case SDCA_CTL_TYPE_S(SAPU, DTODTX_CURRENTOWNER):
 770	case SDCA_CTL_TYPE_S(SAPU, DTODRX_CURRENTOWNER):
 771	case SDCA_CTL_TYPE_S(HIDE, HIDTX_CURRENTOWNER):
 772	case SDCA_CTL_TYPE_S(HIDE, HIDRX_CURRENTOWNER):
 773		return SDCA_CTL_DATATYPE_BITMAP;
 774	case SDCA_CTL_TYPE_S(IT, MATCHING_GUID):
 775	case SDCA_CTL_TYPE_S(OT, MATCHING_GUID):
 776	case SDCA_CTL_TYPE_S(ENTITY_0, MATCHING_GUID):
 777		return SDCA_CTL_DATATYPE_GUID;
 778	default:
 779		return SDCA_CTL_DATATYPE_IMPDEF;
 780	}
 781}
 782
 783static bool find_sdca_control_volatile(const struct sdca_entity *entity,
 784				       const struct sdca_control *control)
 785{
 786	switch (control->mode) {
 787	case SDCA_ACCESS_MODE_DC:
 788		return false;
 789	case SDCA_ACCESS_MODE_RO:
 790	case SDCA_ACCESS_MODE_RW1S:
 791	case SDCA_ACCESS_MODE_RW1C:
 792		return true;
 793	default:
 794		break;
 795	}
 796
 797	switch (SDCA_CTL_TYPE(entity->type, control->sel)) {
 798	case SDCA_CTL_TYPE_S(XU, FDL_CURRENTOWNER):
 799	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGEOFFSET):
 800	case SDCA_CTL_TYPE_S(XU, FDL_MESSAGELENGTH):
 801	case SDCA_CTL_TYPE_S(XU, FDL_STATUS):
 802	case SDCA_CTL_TYPE_S(XU, FDL_HOST_REQUEST):
 803	case SDCA_CTL_TYPE_S(SPE, AUTHTX_CURRENTOWNER):
 804	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGEOFFSET):
 805	case SDCA_CTL_TYPE_S(SPE, AUTHTX_MESSAGELENGTH):
 806	case SDCA_CTL_TYPE_S(SPE, AUTHRX_CURRENTOWNER):
 807	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGEOFFSET):
 808	case SDCA_CTL_TYPE_S(SPE, AUTHRX_MESSAGELENGTH):
 809	case SDCA_CTL_TYPE_S(MFPU, AE_CURRENTOWNER):
 810	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGEOFFSET):
 811	case SDCA_CTL_TYPE_S(MFPU, AE_MESSAGELENGTH):
 812	case SDCA_CTL_TYPE_S(SMPU, HIST_CURRENTOWNER):
 813	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGEOFFSET):
 814	case SDCA_CTL_TYPE_S(SMPU, HIST_MESSAGELENGTH):
 815	case SDCA_CTL_TYPE_S(SMPU, DTODTX_CURRENTOWNER):
 816	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGEOFFSET):
 817	case SDCA_CTL_TYPE_S(SMPU, DTODTX_MESSAGELENGTH):
 818	case SDCA_CTL_TYPE_S(SMPU, DTODRX_CURRENTOWNER):
 819	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGEOFFSET):
 820	case SDCA_CTL_TYPE_S(SMPU, DTODRX_MESSAGELENGTH):
 821	case SDCA_CTL_TYPE_S(SAPU, DTODTX_CURRENTOWNER):
 822	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGEOFFSET):
 823	case SDCA_CTL_TYPE_S(SAPU, DTODTX_MESSAGELENGTH):
 824	case SDCA_CTL_TYPE_S(SAPU, DTODRX_CURRENTOWNER):
 825	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGEOFFSET):
 826	case SDCA_CTL_TYPE_S(SAPU, DTODRX_MESSAGELENGTH):
 827	case SDCA_CTL_TYPE_S(HIDE, HIDTX_CURRENTOWNER):
 828	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGEOFFSET):
 829	case SDCA_CTL_TYPE_S(HIDE, HIDTX_MESSAGELENGTH):
 830	case SDCA_CTL_TYPE_S(HIDE, HIDRX_CURRENTOWNER):
 831	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGEOFFSET):
 832	case SDCA_CTL_TYPE_S(HIDE, HIDRX_MESSAGELENGTH):
 833		return true;
 834	default:
 835		return false;
 836	}
 837}
 838
 839static int find_sdca_control_range(struct device *dev,
 840				   struct fwnode_handle *control_node,
 841				   struct sdca_control_range *range)
 842{
 843	u8 *range_list;
 844	int num_range;
 845	u16 *limits;
 846	int i;
 847
 848	num_range = fwnode_property_count_u8(control_node, "mipi-sdca-control-range");
 849	if (!num_range || num_range == -EINVAL)
 850		return 0;
 851	else if (num_range < 0)
 852		return num_range;
 853
 854	range_list = devm_kcalloc(dev, num_range, sizeof(*range_list), GFP_KERNEL);
 855	if (!range_list)
 856		return -ENOMEM;
 857
 858	fwnode_property_read_u8_array(control_node, "mipi-sdca-control-range",
 859				      range_list, num_range);
 860
 861	limits = (u16 *)range_list;
 862
 863	range->cols = le16_to_cpu(limits[0]);
 864	range->rows = le16_to_cpu(limits[1]);
 865	range->data = (u32 *)&limits[2];
 866
 867	num_range = (num_range - (2 * sizeof(*limits))) / sizeof(*range->data);
 868	if (num_range != range->cols * range->rows)
 869		return -EINVAL;
 870
 871	for (i = 0; i < num_range; i++)
 872		range->data[i] = le32_to_cpu(range->data[i]);
 873
 874	return 0;
 875}
 876
 877static int find_sdca_control_value(struct device *dev, struct sdca_entity *entity,
 878				   struct fwnode_handle *control_node,
 879				   struct sdca_control *control,
 880				   const char * const label)
 881{
 882	char property[SDCA_PROPERTY_LENGTH];
 883	bool global = true;
 884	int ret, cn, i;
 885	u32 tmp;
 886
 887	snprintf(property, sizeof(property), "mipi-sdca-control-%s", label);
 888
 889	ret = fwnode_property_read_u32(control_node, property, &tmp);
 890	if (ret == -EINVAL)
 891		global = false;
 892	else if (ret)
 893		return ret;
 894
 895	i = 0;
 896	for_each_set_bit(cn, (unsigned long *)&control->cn_list,
 897			 BITS_PER_TYPE(control->cn_list)) {
 898		if (!global) {
 899			snprintf(property, sizeof(property),
 900				 "mipi-sdca-control-cn-%d-%s", cn, label);
 901
 902			ret = fwnode_property_read_u32(control_node, property, &tmp);
 903			if (ret)
 904				return ret;
 905		}
 906
 907		control->values[i] = tmp;
 908		i++;
 909	}
 910
 911	return 0;
 912}
 913
 914static int find_sdca_entity_control(struct device *dev, struct sdca_entity *entity,
 915				    struct fwnode_handle *control_node,
 916				    struct sdca_control *control)
 917{
 918	u32 tmp;
 919	int ret;
 920
 921	ret = fwnode_property_read_u32(control_node, "mipi-sdca-control-access-mode", &tmp);
 922	if (ret) {
 923		dev_err(dev, "%s: control %#x: access mode missing: %d\n",
 924			entity->label, control->sel, ret);
 925		return ret;
 926	}
 927
 928	control->mode = tmp;
 929
 930	ret = fwnode_property_read_u32(control_node, "mipi-sdca-control-access-layer", &tmp);
 931	if (ret) {
 932		dev_err(dev, "%s: control %#x: access layer missing: %d\n",
 933			entity->label, control->sel, ret);
 934		return ret;
 935	}
 936
 937	control->layers = tmp;
 938
 939	ret = fwnode_property_read_u64(control_node, "mipi-sdca-control-cn-list",
 940				       &control->cn_list);
 941	if (ret == -EINVAL) {
 942		/* Spec allows not specifying cn-list if only the first number is used */
 943		control->cn_list = 0x1;
 944	} else if (ret || !control->cn_list) {
 945		dev_err(dev, "%s: control %#x: cn list missing: %d\n",
 946			entity->label, control->sel, ret);
 947		return ret;
 948	}
 949
 950	control->values = devm_kcalloc(dev, hweight64(control->cn_list),
 951				       sizeof(int), GFP_KERNEL);
 952	if (!control->values)
 953		return -ENOMEM;
 954
 955	switch (control->mode) {
 956	case SDCA_ACCESS_MODE_DC:
 957		ret = find_sdca_control_value(dev, entity, control_node, control,
 958					      "dc-value");
 959		if (ret) {
 960			dev_err(dev, "%s: control %#x: dc value missing: %d\n",
 961				entity->label, control->sel, ret);
 962			return ret;
 963		}
 964
 965		control->has_fixed = true;
 966		break;
 967	case SDCA_ACCESS_MODE_RW:
 968	case SDCA_ACCESS_MODE_DUAL:
 969		ret = find_sdca_control_value(dev, entity, control_node, control,
 970					      "default-value");
 971		if (!ret)
 972			control->has_default = true;
 973
 974		ret = find_sdca_control_value(dev, entity, control_node, control,
 975					      "fixed-value");
 976		if (!ret)
 977			control->has_fixed = true;
 978		fallthrough;
 979	case SDCA_ACCESS_MODE_RO:
 980		control->deferrable = fwnode_property_read_bool(control_node,
 981								"mipi-sdca-control-deferrable");
 982		break;
 983	default:
 984		break;
 985	}
 986
 987	control->is_volatile = find_sdca_control_volatile(entity, control);
 988
 989	ret = find_sdca_control_range(dev, control_node, &control->range);
 990	if (ret) {
 991		dev_err(dev, "%s: control %#x: range missing: %d\n",
 992			entity->label, control->sel, ret);
 993		return ret;
 994	}
 995
 996	ret = fwnode_property_read_u32(control_node,
 997				       "mipi-sdca-control-interrupt-position",
 998				       &tmp);
 999	if (!ret)
1000		control->interrupt_position = tmp;
1001	else
1002		control->interrupt_position = SDCA_NO_INTERRUPT;
1003
1004	control->label = find_sdca_control_label(dev, entity, control);
1005	if (!control->label)
1006		return -ENOMEM;
1007
1008	control->type = find_sdca_control_datatype(entity, control);
1009	control->nbits = find_sdca_control_bits(entity, control);
1010
1011	dev_dbg(dev, "%s: %s: control %#x mode %#x layers %#x cn %#llx int %d %s\n",
1012		entity->label, control->label, control->sel,
1013		control->mode, control->layers, control->cn_list,
1014		control->interrupt_position, control->deferrable ? "deferrable" : "");
1015
1016	return 0;
1017}
1018
1019static int find_sdca_entity_controls(struct device *dev,
1020				     struct fwnode_handle *entity_node,
1021				     struct sdca_entity *entity)
1022{
1023	struct sdca_control *controls;
1024	int num_controls;
1025	u64 control_list;
1026	int control_sel;
1027	int i, ret;
1028
1029	ret = fwnode_property_read_u64(entity_node, "mipi-sdca-control-list", &control_list);
1030	if (ret == -EINVAL) {
1031		/* Allow missing control lists, assume no controls. */
1032		dev_warn(dev, "%s: missing control list\n", entity->label);
1033		return 0;
1034	} else if (ret) {
1035		dev_err(dev, "%s: failed to read control list: %d\n", entity->label, ret);
1036		return ret;
1037	} else if (!control_list) {
1038		return 0;
1039	}
1040
1041	num_controls = hweight64(control_list);
1042	controls = devm_kcalloc(dev, num_controls, sizeof(*controls), GFP_KERNEL);
1043	if (!controls)
1044		return -ENOMEM;
1045
1046	i = 0;
1047	for_each_set_bit(control_sel, (unsigned long *)&control_list,
1048			 BITS_PER_TYPE(control_list)) {
1049		struct fwnode_handle *control_node;
1050		char control_property[SDCA_PROPERTY_LENGTH];
1051
1052		/* DisCo uses upper-case for hex numbers */
1053		snprintf(control_property, sizeof(control_property),
1054			 "mipi-sdca-control-0x%X-subproperties", control_sel);
1055
1056		control_node = fwnode_get_named_child_node(entity_node, control_property);
1057		if (!control_node) {
1058			dev_err(dev, "%s: control node %s not found\n",
1059				entity->label, control_property);
1060			return -EINVAL;
1061		}
1062
1063		controls[i].sel = control_sel;
1064
1065		ret = find_sdca_entity_control(dev, entity, control_node, &controls[i]);
1066		fwnode_handle_put(control_node);
1067		if (ret)
1068			return ret;
1069
1070		i++;
1071	}
1072
1073	entity->num_controls = num_controls;
1074	entity->controls = controls;
1075
1076	return 0;
1077}
1078
1079static bool find_sdca_iot_dataport(struct sdca_entity_iot *terminal)
1080{
1081	switch (terminal->type) {
1082	case SDCA_TERM_TYPE_GENERIC:
1083	case SDCA_TERM_TYPE_ULTRASOUND:
1084	case SDCA_TERM_TYPE_CAPTURE_DIRECT_PCM_MIC:
1085	case SDCA_TERM_TYPE_RAW_PDM_MIC:
1086	case SDCA_TERM_TYPE_SPEECH:
1087	case SDCA_TERM_TYPE_VOICE:
1088	case SDCA_TERM_TYPE_SECONDARY_PCM_MIC:
1089	case SDCA_TERM_TYPE_ACOUSTIC_CONTEXT_AWARENESS:
1090	case SDCA_TERM_TYPE_DTOD_STREAM:
1091	case SDCA_TERM_TYPE_REFERENCE_STREAM:
1092	case SDCA_TERM_TYPE_SENSE_CAPTURE:
1093	case SDCA_TERM_TYPE_STREAMING_MIC:
1094	case SDCA_TERM_TYPE_OPTIMIZATION_STREAM:
1095	case SDCA_TERM_TYPE_PDM_RENDER_STREAM:
1096	case SDCA_TERM_TYPE_COMPANION_DATA:
1097		return true;
1098	default:
1099		return false;
1100	}
1101}
1102
1103static int find_sdca_entity_iot(struct device *dev,
1104				struct fwnode_handle *entity_node,
1105				struct sdca_entity *entity)
1106{
1107	struct sdca_entity_iot *terminal = &entity->iot;
1108	u32 tmp;
1109	int ret;
1110
1111	ret = fwnode_property_read_u32(entity_node, "mipi-sdca-terminal-type", &tmp);
1112	if (ret) {
1113		dev_err(dev, "%s: terminal type missing: %d\n", entity->label, ret);
1114		return ret;
1115	}
1116
1117	terminal->type = tmp;
1118	terminal->is_dataport = find_sdca_iot_dataport(terminal);
1119
1120	if (!terminal->is_dataport) {
1121		const char *type_name = sdca_find_terminal_name(terminal->type);
1122
1123		if (type_name) {
1124			entity->label = devm_kasprintf(dev, GFP_KERNEL, "%s %s",
1125						       entity->label, type_name);
1126			if (!entity->label)
1127				return -ENOMEM;
1128		}
1129	}
1130
1131	ret = fwnode_property_read_u32(entity_node,
1132				       "mipi-sdca-terminal-reference-number", &tmp);
1133	if (!ret)
1134		terminal->reference = tmp;
1135
1136	ret = fwnode_property_read_u32(entity_node,
1137				       "mipi-sdca-terminal-connector-type", &tmp);
1138	if (!ret)
1139		terminal->connector = tmp;
1140
1141	ret = fwnode_property_read_u32(entity_node,
1142				       "mipi-sdca-terminal-transducer-count", &tmp);
1143	if (!ret)
1144		terminal->num_transducer = tmp;
1145
1146	dev_dbg(dev, "%s: terminal type %#x ref %#x conn %#x count %d\n",
1147		entity->label, terminal->type, terminal->reference,
1148		terminal->connector, terminal->num_transducer);
1149
1150	return 0;
1151}
1152
1153static int find_sdca_entity_cs(struct device *dev,
1154			       struct fwnode_handle *entity_node,
1155			       struct sdca_entity *entity)
1156{
1157	struct sdca_entity_cs *clock = &entity->cs;
1158	u32 tmp;
1159	int ret;
1160
1161	ret = fwnode_property_read_u32(entity_node, "mipi-sdca-cs-type", &tmp);
1162	if (ret) {
1163		dev_err(dev, "%s: clock type missing: %d\n", entity->label, ret);
1164		return ret;
1165	}
1166
1167	clock->type = tmp;
1168
1169	ret = fwnode_property_read_u32(entity_node,
1170				       "mipi-sdca-clock-valid-max-delay", &tmp);
1171	if (!ret)
1172		clock->max_delay = tmp;
1173
1174	dev_dbg(dev, "%s: clock type %#x delay %d\n", entity->label,
1175		clock->type, clock->max_delay);
1176
1177	return 0;
1178}
1179
1180static int find_sdca_entity_pde(struct device *dev,
1181				struct fwnode_handle *entity_node,
1182				struct sdca_entity *entity)
1183{
1184	static const int mult_delay = 3;
1185	struct sdca_entity_pde *power = &entity->pde;
1186	u32 *delay_list __free(kfree) = NULL;
1187	struct sdca_pde_delay *delays;
1188	int num_delays;
1189	int i, j;
1190
1191	num_delays = fwnode_property_count_u32(entity_node,
1192					       "mipi-sdca-powerdomain-transition-max-delay");
1193	if (num_delays <= 0) {
1194		dev_err(dev, "%s: max delay list missing: %d\n",
1195			entity->label, num_delays);
1196		return -EINVAL;
1197	} else if (num_delays % mult_delay != 0) {
1198		dev_err(dev, "%s: delays not multiple of %d\n",
1199			entity->label, mult_delay);
1200		return -EINVAL;
1201	} else if (num_delays > SDCA_MAX_DELAY_COUNT) {
1202		dev_err(dev, "%s: maximum number of transition delays exceeded\n",
1203			entity->label);
1204		return -EINVAL;
1205	}
1206
1207	delay_list = kcalloc(num_delays, sizeof(*delay_list), GFP_KERNEL);
1208	if (!delay_list)
1209		return -ENOMEM;
1210
1211	fwnode_property_read_u32_array(entity_node,
1212				       "mipi-sdca-powerdomain-transition-max-delay",
1213				       delay_list, num_delays);
1214
1215	num_delays /= mult_delay;
1216
1217	delays = devm_kcalloc(dev, num_delays, sizeof(*delays), GFP_KERNEL);
1218	if (!delays)
1219		return -ENOMEM;
1220
1221	for (i = 0, j = 0; i < num_delays; i++) {
1222		delays[i].from_ps = delay_list[j++];
1223		delays[i].to_ps = delay_list[j++];
1224		delays[i].us = delay_list[j++];
1225
1226		dev_dbg(dev, "%s: from %#x to %#x delay %dus\n", entity->label,
1227			delays[i].from_ps, delays[i].to_ps, delays[i].us);
1228	}
1229
1230	power->num_max_delay = num_delays;
1231	power->max_delay = delays;
1232
1233	return 0;
1234}
1235
1236struct raw_ge_mode {
1237	u8 val;
1238	u8 num_controls;
1239	struct {
1240		u8 id;
1241		u8 sel;
1242		u8 cn;
1243		__le32 val;
1244	} __packed controls[] __counted_by(num_controls);
1245} __packed;
1246
1247static int find_sdca_entity_ge(struct device *dev,
1248			       struct fwnode_handle *entity_node,
1249			       struct sdca_entity *entity)
1250{
1251	struct sdca_entity_ge *group = &entity->ge;
1252	u8 *affected_list __free(kfree) = NULL;
1253	u8 *affected_iter;
1254	int num_affected;
1255	int i, j;
1256
1257	num_affected = fwnode_property_count_u8(entity_node,
1258						"mipi-sdca-ge-selectedmode-controls-affected");
1259	if (!num_affected) {
1260		return 0;
1261	} else if (num_affected < 0) {
1262		dev_err(dev, "%s: failed to read affected controls: %d\n",
1263			entity->label, num_affected);
1264		return num_affected;
1265	} else if (num_affected > SDCA_MAX_AFFECTED_COUNT) {
1266		dev_err(dev, "%s: maximum affected controls size exceeded\n",
1267			entity->label);
1268		return -EINVAL;
1269	}
1270
1271	affected_list = kcalloc(num_affected, sizeof(*affected_list), GFP_KERNEL);
1272	if (!affected_list)
1273		return -ENOMEM;
1274
1275	fwnode_property_read_u8_array(entity_node,
1276				      "mipi-sdca-ge-selectedmode-controls-affected",
1277				      affected_list, num_affected);
1278
1279	group->num_modes = *affected_list;
1280	affected_iter = affected_list + 1;
1281
1282	group->modes = devm_kcalloc(dev, group->num_modes, sizeof(*group->modes),
1283				    GFP_KERNEL);
1284	if (!group->modes)
1285		return -ENOMEM;
1286
1287	for (i = 0; i < group->num_modes; i++) {
1288		struct raw_ge_mode *raw = (struct raw_ge_mode *)affected_iter;
1289		struct sdca_ge_mode *mode = &group->modes[i];
1290
1291		affected_iter += sizeof(*raw);
1292		if (affected_iter > affected_list + num_affected)
1293			goto bad_list;
1294
1295		mode->val = raw->val;
1296		mode->num_controls = raw->num_controls;
1297
1298		affected_iter += mode->num_controls * sizeof(raw->controls[0]);
1299		if (affected_iter > affected_list + num_affected)
1300			goto bad_list;
1301
1302		mode->controls = devm_kcalloc(dev, mode->num_controls,
1303					      sizeof(*mode->controls), GFP_KERNEL);
1304		if (!mode->controls)
1305			return -ENOMEM;
1306
1307		for (j = 0; j < mode->num_controls; j++) {
1308			mode->controls[j].id = raw->controls[j].id;
1309			mode->controls[j].sel = raw->controls[j].sel;
1310			mode->controls[j].cn = raw->controls[j].cn;
1311			mode->controls[j].val = le32_to_cpu(raw->controls[j].val);
1312		}
1313	}
1314
1315	return 0;
1316
1317bad_list:
1318	dev_err(dev, "%s: malformed affected controls list\n", entity->label);
1319	return -EINVAL;
1320}
1321
1322static int
1323find_sdca_entity_hide(struct device *dev, struct sdw_slave *sdw,
1324		      struct fwnode_handle *function_node,
1325		      struct fwnode_handle *entity_node, struct sdca_entity *entity)
1326{
1327	struct sdca_entity_hide *hide = &entity->hide;
1328	unsigned int delay, *af_list = hide->af_number_list;
1329	int nval, ret;
1330	unsigned char *report_desc = NULL;
1331
1332	ret = fwnode_property_read_u32(entity_node,
1333				       "mipi-sdca-RxUMP-ownership-transition-max-delay", &delay);
1334	if (!ret)
1335		hide->max_delay = delay;
1336
1337	nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDTx-supported-report-ids");
1338	if (nval > 0) {
1339		hide->num_hidtx_ids = nval;
1340		hide->hidtx_ids = devm_kcalloc(dev, hide->num_hidtx_ids,
1341					       sizeof(*hide->hidtx_ids), GFP_KERNEL);
1342		if (!hide->hidtx_ids)
1343			return -ENOMEM;
1344
1345		ret = fwnode_property_read_u32_array(entity_node,
1346						     "mipi-sdca-HIDTx-supported-report-ids",
1347						     hide->hidtx_ids,
1348						     hide->num_hidtx_ids);
1349		if (ret < 0)
1350			return ret;
1351	}
1352
1353	nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDRx-supported-report-ids");
1354	if (nval > 0) {
1355		hide->num_hidrx_ids = nval;
1356		hide->hidrx_ids = devm_kcalloc(dev, hide->num_hidrx_ids,
1357					       sizeof(*hide->hidrx_ids), GFP_KERNEL);
1358		if (!hide->hidrx_ids)
1359			return -ENOMEM;
1360
1361		ret = fwnode_property_read_u32_array(entity_node,
1362						     "mipi-sdca-HIDRx-supported-report-ids",
1363						     hide->hidrx_ids,
1364						     hide->num_hidrx_ids);
1365		if (ret < 0)
1366			return ret;
1367	}
1368
1369	nval = fwnode_property_count_u32(entity_node, "mipi-sdca-hide-related-audio-function-list");
1370	if (nval <= 0) {
1371		dev_err(dev, "%pfwP: audio function numbers list missing: %d\n",
1372			entity_node, nval);
1373		return -EINVAL;
1374	} else if (nval > SDCA_MAX_FUNCTION_COUNT) {
1375		dev_err(dev, "%pfwP: maximum number of audio function exceeded\n", entity_node);
1376		return -EINVAL;
1377	}
1378
1379	hide->hide_reside_function_num = nval;
1380	fwnode_property_read_u32_array(entity_node,
1381				       "mipi-sdca-hide-related-audio-function-list", af_list, nval);
1382
1383	nval = fwnode_property_count_u8(function_node, "mipi-sdca-hid-descriptor");
1384	if (nval)
1385		fwnode_property_read_u8_array(function_node, "mipi-sdca-hid-descriptor",
1386					      (u8 *)&hide->hid_desc, nval);
1387
1388	if (hide->hid_desc.bNumDescriptors) {
1389		nval = fwnode_property_count_u8(function_node, "mipi-sdca-report-descriptor");
1390		if (nval) {
1391			report_desc = devm_kzalloc(dev, nval, GFP_KERNEL);
1392			if (!report_desc)
1393				return -ENOMEM;
1394			hide->hid_report_desc = report_desc;
1395			fwnode_property_read_u8_array(function_node, "mipi-sdca-report-descriptor",
1396						      report_desc, nval);
1397
1398			/* add HID device */
1399			ret = sdca_add_hid_device(dev, sdw, entity);
1400			if (ret) {
1401				dev_err(dev, "%pfwP: failed to add HID device: %d\n", entity_node, ret);
1402				return ret;
1403			}
1404		}
1405	}
1406
1407	return 0;
1408}
1409
1410static int find_sdca_entity_xu(struct device *dev,
1411			       struct fwnode_handle *entity_node,
1412			       struct sdca_entity *entity)
1413{
1414	struct sdca_entity_xu *xu = &entity->xu;
1415	u32 tmp;
1416	int ret;
1417
1418	ret = fwnode_property_read_u32(entity_node,
1419				       "mipi-sdca-RxUMP-ownership-transition-max-delay",
1420				       &tmp);
1421	if (!ret)
1422		xu->max_delay = tmp;
1423
1424	ret = fwnode_property_read_u32(entity_node, "mipi-sdca-FDL-reset-mechanism",
1425				       &tmp);
1426	if (!ret)
1427		xu->reset_mechanism = tmp;
1428
1429	return 0;
1430}
1431
1432static int find_sdca_entity(struct device *dev, struct sdw_slave *sdw,
1433			    struct fwnode_handle *function_node,
1434			    struct fwnode_handle *entity_node,
1435			    struct sdca_entity *entity)
1436{
1437	u32 tmp;
1438	int ret;
1439
1440	ret = fwnode_property_read_string(entity_node, "mipi-sdca-entity-label",
1441					  &entity->label);
1442	if (ret) {
1443		dev_err(dev, "%pfwP: entity %#x: label missing: %d\n",
1444			function_node, entity->id, ret);
1445		return ret;
1446	}
1447
1448	ret = fwnode_property_read_u32(entity_node, "mipi-sdca-entity-type", &tmp);
1449	if (ret) {
1450		dev_err(dev, "%s: type missing: %d\n", entity->label, ret);
1451		return ret;
1452	}
1453
1454	entity->type = tmp;
1455
1456	dev_dbg(dev, "%s: entity %#x type %#x\n",
1457		entity->label, entity->id, entity->type);
1458
1459	switch (entity->type) {
1460	case SDCA_ENTITY_TYPE_IT:
1461	case SDCA_ENTITY_TYPE_OT:
1462		ret = find_sdca_entity_iot(dev, entity_node, entity);
1463		break;
1464	case SDCA_ENTITY_TYPE_XU:
1465		ret = find_sdca_entity_xu(dev, entity_node, entity);
1466		break;
1467	case SDCA_ENTITY_TYPE_CS:
1468		ret = find_sdca_entity_cs(dev, entity_node, entity);
1469		break;
1470	case SDCA_ENTITY_TYPE_PDE:
1471		ret = find_sdca_entity_pde(dev, entity_node, entity);
1472		break;
1473	case SDCA_ENTITY_TYPE_GE:
1474		ret = find_sdca_entity_ge(dev, entity_node, entity);
1475		break;
1476	case SDCA_ENTITY_TYPE_HIDE:
1477		ret = find_sdca_entity_hide(dev, sdw, function_node,
1478					    entity_node, entity);
1479		break;
1480	default:
1481		break;
1482	}
1483	if (ret)
1484		return ret;
1485
1486	ret = find_sdca_entity_controls(dev, entity_node, entity);
1487	if (ret)
1488		return ret;
1489
1490	return 0;
1491}
1492
1493static int find_sdca_entities(struct device *dev, struct sdw_slave *sdw,
1494			      struct fwnode_handle *function_node,
1495			      struct sdca_function_data *function)
1496{
1497	u32 *entity_list __free(kfree) = NULL;
1498	struct sdca_entity *entities;
1499	int num_entities;
1500	int i, ret;
1501
1502	num_entities = fwnode_property_count_u32(function_node,
1503						 "mipi-sdca-entity-id-list");
1504	if (num_entities <= 0) {
1505		dev_err(dev, "%pfwP: entity id list missing: %d\n",
1506			function_node, num_entities);
1507		return -EINVAL;
1508	} else if (num_entities > SDCA_MAX_ENTITY_COUNT) {
1509		dev_err(dev, "%pfwP: maximum number of entities exceeded\n",
1510			function_node);
1511		return -EINVAL;
1512	}
1513
1514	/* Add 1 to make space for Entity 0 */
1515	entities = devm_kcalloc(dev, num_entities + 1, sizeof(*entities), GFP_KERNEL);
1516	if (!entities)
1517		return -ENOMEM;
1518
1519	entity_list = kcalloc(num_entities, sizeof(*entity_list), GFP_KERNEL);
1520	if (!entity_list)
1521		return -ENOMEM;
1522
1523	fwnode_property_read_u32_array(function_node, "mipi-sdca-entity-id-list",
1524				       entity_list, num_entities);
1525
1526	for (i = 0; i < num_entities; i++)
1527		entities[i].id = entity_list[i];
1528
1529	/* now read subproperties */
1530	for (i = 0; i < num_entities; i++) {
1531		char entity_property[SDCA_PROPERTY_LENGTH];
1532		struct fwnode_handle *entity_node;
1533
1534		/* DisCo uses upper-case for hex numbers */
1535		snprintf(entity_property, sizeof(entity_property),
1536			 "mipi-sdca-entity-id-0x%X-subproperties", entities[i].id);
1537
1538		entity_node = fwnode_get_named_child_node(function_node, entity_property);
1539		if (!entity_node) {
1540			dev_err(dev, "%pfwP: entity node %s not found\n",
1541				function_node, entity_property);
1542			return -EINVAL;
1543		}
1544
1545		ret = find_sdca_entity(dev, sdw, function_node,
1546				       entity_node, &entities[i]);
1547		fwnode_handle_put(entity_node);
1548		if (ret)
1549			return ret;
1550	}
1551
1552	/*
1553	 * Add Entity 0 at end of the array, makes it easy to skip during
1554	 * all the Entity searches involved in creating connections.
1555	 */
1556	entities[num_entities].label = "entity0";
1557
1558	ret = find_sdca_entity_controls(dev, function_node, &entities[num_entities]);
1559	if (ret)
1560		return ret;
1561
1562	function->num_entities = num_entities + 1;
1563	function->entities = entities;
1564
1565	return 0;
1566}
1567
1568static struct sdca_entity *find_sdca_entity_by_label(struct sdca_function_data *function,
1569						     const char *entity_label)
1570{
1571	struct sdca_entity *entity = NULL;
1572	int i;
1573
1574	for (i = 0; i < function->num_entities; i++) {
1575		entity = &function->entities[i];
1576
1577		/* check whole string first*/
1578		if (!strcmp(entity->label, entity_label))
1579			return entity;
1580	}
1581
1582	for (i = 0; i < function->num_entities; i++) {
1583		entity = &function->entities[i];
1584
1585		if (!strncmp(entity->label, entity_label, strlen(entity_label)))
1586			return entity;
1587	}
1588
1589	return NULL;
1590}
1591
1592static struct sdca_entity *find_sdca_entity_by_id(struct sdca_function_data *function,
1593						  const int id)
1594{
1595	int i;
1596
1597	for (i = 0; i < function->num_entities; i++) {
1598		struct sdca_entity *entity = &function->entities[i];
1599
1600		if (entity->id == id)
1601			return entity;
1602	}
1603
1604	return NULL;
1605}
1606
1607static int find_sdca_entity_connection_iot(struct device *dev,
1608					   struct sdca_function_data *function,
1609					   struct fwnode_handle *entity_node,
1610					   struct sdca_entity *entity)
1611{
1612	struct sdca_entity_iot *terminal = &entity->iot;
1613	struct fwnode_handle *clock_node;
1614	struct sdca_entity *clock_entity;
1615	const char *clock_label;
1616	int ret;
1617
1618	clock_node = fwnode_get_named_child_node(entity_node,
1619						 "mipi-sdca-terminal-clock-connection");
1620	if (!clock_node)
1621		return 0;
1622
1623	ret = fwnode_property_read_string(clock_node, "mipi-sdca-entity-label",
1624					  &clock_label);
1625	if (ret) {
1626		dev_err(dev, "%s: clock label missing: %d\n", entity->label, ret);
1627		fwnode_handle_put(clock_node);
1628		return ret;
1629	}
1630
1631	clock_entity = find_sdca_entity_by_label(function, clock_label);
1632	if (!clock_entity) {
1633		dev_err(dev, "%s: failed to find clock with label %s\n",
1634			entity->label, clock_label);
1635		fwnode_handle_put(clock_node);
1636		return -EINVAL;
1637	}
1638
1639	terminal->clock = clock_entity;
1640
1641	dev_dbg(dev, "%s -> %s\n", clock_entity->label, entity->label);
1642
1643	fwnode_handle_put(clock_node);
1644	return 0;
1645}
1646
1647static int find_sdca_entity_connection_pde(struct device *dev,
1648					   struct sdca_function_data *function,
1649					   struct fwnode_handle *entity_node,
1650					   struct sdca_entity *entity)
1651{
1652	struct sdca_entity_pde *power = &entity->pde;
1653	u32 *managed_list __free(kfree) = NULL;
1654	struct sdca_entity **managed;
1655	int num_managed;
1656	int i;
1657
1658	num_managed = fwnode_property_count_u32(entity_node,
1659						"mipi-sdca-powerdomain-managed-list");
1660	if (!num_managed) {
1661		return 0;
1662	} else if (num_managed < 0) {
1663		dev_err(dev, "%s: managed list missing: %d\n", entity->label, num_managed);
1664		return num_managed;
1665	} else if (num_managed > SDCA_MAX_ENTITY_COUNT) {
1666		dev_err(dev, "%s: maximum number of managed entities exceeded\n",
1667			entity->label);
1668		return -EINVAL;
1669	}
1670
1671	managed = devm_kcalloc(dev, num_managed, sizeof(*managed), GFP_KERNEL);
1672	if (!managed)
1673		return -ENOMEM;
1674
1675	managed_list = kcalloc(num_managed, sizeof(*managed_list), GFP_KERNEL);
1676	if (!managed_list)
1677		return -ENOMEM;
1678
1679	fwnode_property_read_u32_array(entity_node,
1680				       "mipi-sdca-powerdomain-managed-list",
1681				       managed_list, num_managed);
1682
1683	for (i = 0; i < num_managed; i++) {
1684		managed[i] = find_sdca_entity_by_id(function, managed_list[i]);
1685		if (!managed[i]) {
1686			dev_err(dev, "%s: failed to find entity with id %#x\n",
1687				entity->label, managed_list[i]);
1688			return -EINVAL;
1689		}
1690
1691		dev_dbg(dev, "%s -> %s\n", managed[i]->label, entity->label);
1692	}
1693
1694	power->num_managed = num_managed;
1695	power->managed = managed;
1696
1697	return 0;
1698}
1699
1700static int find_sdca_entity_connection_ge(struct device *dev,
1701					  struct sdca_function_data *function,
1702					  struct fwnode_handle *entity_node,
1703					  struct sdca_entity *entity)
1704{
1705	int i, j;
1706
1707	for (i = 0; i < entity->ge.num_modes; i++) {
1708		struct sdca_ge_mode *mode = &entity->ge.modes[i];
1709
1710		for (j = 0; j < mode->num_controls; j++) {
1711			struct sdca_ge_control *affected = &mode->controls[j];
1712			struct sdca_entity *managed;
1713
1714			managed = find_sdca_entity_by_id(function, affected->id);
1715			if (!managed) {
1716				dev_err(dev, "%s: failed to find entity with id %#x\n",
1717					entity->label, affected->id);
1718				return -EINVAL;
1719			}
1720
1721			if (managed->group && managed->group != entity) {
1722				dev_err(dev,
1723					"%s: entity controlled by two groups %s, %s\n",
1724					managed->label, managed->group->label,
1725					entity->label);
1726				return -EINVAL;
1727			}
1728
1729			managed->group = entity;
1730		}
1731	}
1732
1733	return 0;
1734}
1735
1736static int find_sdca_entity_connection(struct device *dev,
1737				       struct sdca_function_data *function,
1738				       struct fwnode_handle *entity_node,
1739				       struct sdca_entity *entity)
1740{
1741	struct sdca_entity **pins;
1742	int num_pins, pin;
1743	u64 pin_list;
1744	int i, ret;
1745
1746	switch (entity->type) {
1747	case SDCA_ENTITY_TYPE_IT:
1748	case SDCA_ENTITY_TYPE_OT:
1749		ret = find_sdca_entity_connection_iot(dev, function,
1750						      entity_node, entity);
1751		break;
1752	case SDCA_ENTITY_TYPE_PDE:
1753		ret = find_sdca_entity_connection_pde(dev, function,
1754						      entity_node, entity);
1755		break;
1756	case SDCA_ENTITY_TYPE_GE:
1757		ret = find_sdca_entity_connection_ge(dev, function,
1758						     entity_node, entity);
1759		break;
1760	default:
1761		ret = 0;
1762		break;
1763	}
1764	if (ret)
1765		return ret;
1766
1767	ret = fwnode_property_read_u64(entity_node, "mipi-sdca-input-pin-list", &pin_list);
1768	if (ret == -EINVAL) {
1769		/* Allow missing pin lists, assume no pins. */
1770		return 0;
1771	} else if (ret) {
1772		dev_err(dev, "%s: failed to read pin list: %d\n", entity->label, ret);
1773		return ret;
1774	} else if (pin_list & BIT(0)) {
1775		/*
1776		 * Each bit set in the pin-list refers to an entity_id in this
1777		 * Function. Entity 0 is an illegal connection since it is used
1778		 * for Function-level configurations.
1779		 */
1780		dev_err(dev, "%s: pin 0 used as input\n", entity->label);
1781		return -EINVAL;
1782	} else if (!pin_list) {
1783		return 0;
1784	}
1785
1786	num_pins = hweight64(pin_list);
1787	pins = devm_kcalloc(dev, num_pins, sizeof(*pins), GFP_KERNEL);
1788	if (!pins)
1789		return -ENOMEM;
1790
1791	i = 0;
1792	for_each_set_bit(pin, (unsigned long *)&pin_list, BITS_PER_TYPE(pin_list)) {
1793		char pin_property[SDCA_PROPERTY_LENGTH];
1794		struct fwnode_handle *connected_node;
1795		struct sdca_entity *connected_entity;
1796		const char *connected_label;
1797
1798		snprintf(pin_property, sizeof(pin_property), "mipi-sdca-input-pin-%d", pin);
1799
1800		connected_node = fwnode_get_named_child_node(entity_node, pin_property);
1801		if (!connected_node) {
1802			dev_err(dev, "%s: pin node %s not found\n",
1803				entity->label, pin_property);
1804			return -EINVAL;
1805		}
1806
1807		ret = fwnode_property_read_string(connected_node, "mipi-sdca-entity-label",
1808						  &connected_label);
1809		if (ret) {
1810			dev_err(dev, "%s: pin %d label missing: %d\n",
1811				entity->label, pin, ret);
1812			fwnode_handle_put(connected_node);
1813			return ret;
1814		}
1815
1816		connected_entity = find_sdca_entity_by_label(function, connected_label);
1817		if (!connected_entity) {
1818			dev_err(dev, "%s: failed to find entity with label %s\n",
1819				entity->label, connected_label);
1820			fwnode_handle_put(connected_node);
1821			return -EINVAL;
1822		}
1823
1824		pins[i] = connected_entity;
1825
1826		dev_dbg(dev, "%s -> %s\n", connected_entity->label, entity->label);
1827
1828		i++;
1829		fwnode_handle_put(connected_node);
1830	}
1831
1832	entity->num_sources = num_pins;
1833	entity->sources = pins;
1834
1835	return 0;
1836}
1837
1838static int find_sdca_connections(struct device *dev,
1839				 struct fwnode_handle *function_node,
1840				 struct sdca_function_data *function)
1841{
1842	int i;
1843
1844	/* Entity 0 cannot have connections */
1845	for (i = 0; i < function->num_entities - 1; i++) {
1846		struct sdca_entity *entity = &function->entities[i];
1847		char entity_property[SDCA_PROPERTY_LENGTH];
1848		struct fwnode_handle *entity_node;
1849		int ret;
1850
1851		/* DisCo uses upper-case for hex numbers */
1852		snprintf(entity_property, sizeof(entity_property),
1853			 "mipi-sdca-entity-id-0x%X-subproperties",
1854			 entity->id);
1855
1856		entity_node = fwnode_get_named_child_node(function_node, entity_property);
1857		if (!entity_node) {
1858			dev_err(dev, "%pfwP: entity node %s not found\n",
1859				function_node, entity_property);
1860			return -EINVAL;
1861		}
1862
1863		ret = find_sdca_entity_connection(dev, function, entity_node, entity);
1864		fwnode_handle_put(entity_node);
1865		if (ret)
1866			return ret;
1867	}
1868
1869	return 0;
1870}
1871
1872static int find_sdca_cluster_channel(struct device *dev,
1873				     struct sdca_cluster *cluster,
1874				     struct fwnode_handle *channel_node,
1875				     struct sdca_channel *channel)
1876{
1877	u32 tmp;
1878	int ret;
1879
1880	ret = fwnode_property_read_u32(channel_node, "mipi-sdca-cluster-channel-id", &tmp);
1881	if (ret) {
1882		dev_err(dev, "cluster %#x: missing channel id: %d\n",
1883			cluster->id, ret);
1884		return ret;
1885	}
1886
1887	channel->id = tmp;
1888
1889	ret = fwnode_property_read_u32(channel_node,
1890				       "mipi-sdca-cluster-channel-purpose",
1891				       &tmp);
1892	if (ret) {
1893		dev_err(dev, "cluster %#x: channel %#x: missing purpose: %d\n",
1894			cluster->id, channel->id, ret);
1895		return ret;
1896	}
1897
1898	channel->purpose = tmp;
1899
1900	ret = fwnode_property_read_u32(channel_node,
1901				       "mipi-sdca-cluster-channel-relationship",
1902				       &tmp);
1903	if (ret) {
1904		dev_err(dev, "cluster %#x: channel %#x: missing relationship: %d\n",
1905			cluster->id, channel->id, ret);
1906		return ret;
1907	}
1908
1909	channel->relationship = tmp;
1910
1911	dev_dbg(dev, "cluster %#x: channel id %#x purpose %#x relationship %#x\n",
1912		cluster->id, channel->id, channel->purpose, channel->relationship);
1913
1914	return 0;
1915}
1916
1917static int find_sdca_cluster_channels(struct device *dev,
1918				      struct fwnode_handle *cluster_node,
1919				      struct sdca_cluster *cluster)
1920{
1921	struct sdca_channel *channels;
1922	u32 num_channels;
1923	int i, ret;
1924
1925	ret = fwnode_property_read_u32(cluster_node, "mipi-sdca-channel-count",
1926				       &num_channels);
1927	if (ret < 0) {
1928		dev_err(dev, "cluster %#x: failed to read channel list: %d\n",
1929			cluster->id, ret);
1930		return ret;
1931	} else if (num_channels > SDCA_MAX_CHANNEL_COUNT) {
1932		dev_err(dev, "cluster %#x: maximum number of channels exceeded\n",
1933			cluster->id);
1934		return -EINVAL;
1935	}
1936
1937	channels = devm_kcalloc(dev, num_channels, sizeof(*channels), GFP_KERNEL);
1938	if (!channels)
1939		return -ENOMEM;
1940
1941	for (i = 0; i < num_channels; i++) {
1942		char channel_property[SDCA_PROPERTY_LENGTH];
1943		struct fwnode_handle *channel_node;
1944
1945		/* DisCo uses upper-case for hex numbers */
1946		snprintf(channel_property, sizeof(channel_property),
1947			 "mipi-sdca-channel-%d-subproperties", i + 1);
1948
1949		channel_node = fwnode_get_named_child_node(cluster_node, channel_property);
1950		if (!channel_node) {
1951			dev_err(dev, "cluster %#x: channel node %s not found\n",
1952				cluster->id, channel_property);
1953			return -EINVAL;
1954		}
1955
1956		ret = find_sdca_cluster_channel(dev, cluster, channel_node, &channels[i]);
1957		fwnode_handle_put(channel_node);
1958		if (ret)
1959			return ret;
1960	}
1961
1962	cluster->num_channels = num_channels;
1963	cluster->channels = channels;
1964
1965	return 0;
1966}
1967
1968static int find_sdca_clusters(struct device *dev,
1969			      struct fwnode_handle *function_node,
1970			      struct sdca_function_data *function)
1971{
1972	u32 *cluster_list __free(kfree) = NULL;
1973	struct sdca_cluster *clusters;
1974	int num_clusters;
1975	int i, ret;
1976
1977	num_clusters = fwnode_property_count_u32(function_node, "mipi-sdca-cluster-id-list");
1978	if (!num_clusters || num_clusters == -EINVAL) {
1979		return 0;
1980	} else if (num_clusters < 0) {
1981		dev_err(dev, "%pfwP: failed to read cluster id list: %d\n",
1982			function_node, num_clusters);
1983		return num_clusters;
1984	} else if (num_clusters > SDCA_MAX_CLUSTER_COUNT) {
1985		dev_err(dev, "%pfwP: maximum number of clusters exceeded\n", function_node);
1986		return -EINVAL;
1987	}
1988
1989	clusters = devm_kcalloc(dev, num_clusters, sizeof(*clusters), GFP_KERNEL);
1990	if (!clusters)
1991		return -ENOMEM;
1992
1993	cluster_list = kcalloc(num_clusters, sizeof(*cluster_list), GFP_KERNEL);
1994	if (!cluster_list)
1995		return -ENOMEM;
1996
1997	fwnode_property_read_u32_array(function_node, "mipi-sdca-cluster-id-list",
1998				       cluster_list, num_clusters);
1999
2000	for (i = 0; i < num_clusters; i++)
2001		clusters[i].id = cluster_list[i];
2002
2003	/* now read subproperties */
2004	for (i = 0; i < num_clusters; i++) {
2005		char cluster_property[SDCA_PROPERTY_LENGTH];
2006		struct fwnode_handle *cluster_node;
2007
2008		/* DisCo uses upper-case for hex numbers */
2009		snprintf(cluster_property, sizeof(cluster_property),
2010			 "mipi-sdca-cluster-id-0x%X-subproperties", clusters[i].id);
2011
2012		cluster_node = fwnode_get_named_child_node(function_node, cluster_property);
2013		if (!cluster_node) {
2014			dev_err(dev, "%pfwP: cluster node %s not found\n",
2015				function_node, cluster_property);
2016			return -EINVAL;
2017		}
2018
2019		ret = find_sdca_cluster_channels(dev, cluster_node, &clusters[i]);
2020		fwnode_handle_put(cluster_node);
2021		if (ret)
2022			return ret;
2023	}
2024
2025	function->num_clusters = num_clusters;
2026	function->clusters = clusters;
2027
2028	return 0;
2029}
2030
2031static int find_sdca_filesets(struct device *dev, struct sdw_slave *sdw,
2032			      struct fwnode_handle *function_node,
2033			      struct sdca_function_data *function)
2034{
2035	static const int mult_fileset = 3;
2036	char fileset_name[SDCA_PROPERTY_LENGTH];
2037	u32 *filesets_list __free(kfree) = NULL;
2038	struct sdca_fdl_set *sets;
2039	int num_sets;
2040	int i, j;
2041
2042	num_sets = fwnode_property_count_u32(function_node,
2043					     "mipi-sdca-file-set-id-list");
2044	if (num_sets == 0 || num_sets == -EINVAL) {
2045		return 0;
2046	} else if (num_sets < 0) {
2047		dev_err(dev, "%pfwP: failed to read file set list: %d\n",
2048			function_node, num_sets);
2049		return num_sets;
2050	}
2051
2052	filesets_list = kcalloc(num_sets, sizeof(u32), GFP_KERNEL);
2053	if (!filesets_list)
2054		return -ENOMEM;
2055
2056	fwnode_property_read_u32_array(function_node, "mipi-sdca-file-set-id-list",
2057				       filesets_list, num_sets);
2058
2059	sets = devm_kcalloc(dev, num_sets, sizeof(struct sdca_fdl_set), GFP_KERNEL);
2060	if (!sets)
2061		return -ENOMEM;
2062
2063	for (i = 0; i < num_sets; i++) {
2064		u32 *fileset_entries __free(kfree) = NULL;
2065		struct sdca_fdl_set *set = &sets[i];
2066		struct sdca_fdl_file *files;
2067		int num_files, num_entries;
2068
2069		snprintf(fileset_name, sizeof(fileset_name),
2070			 "mipi-sdca-file-set-id-0x%X", filesets_list[i]);
2071
2072		num_entries = fwnode_property_count_u32(function_node, fileset_name);
2073		if (num_entries <= 0) {
2074			dev_err(dev, "%pfwP: file set %d missing entries: %d\n",
2075				function_node, filesets_list[i], num_entries);
2076			return -EINVAL;
2077		} else if (num_entries % mult_fileset != 0) {
2078			dev_err(dev, "%pfwP: file set %d files not multiple of %d\n",
2079				function_node, filesets_list[i], mult_fileset);
2080			return -EINVAL;
2081		}
2082
2083		dev_dbg(dev, "fileset: %#x\n", filesets_list[i]);
2084
2085		files = devm_kcalloc(dev, num_entries / mult_fileset,
2086				     sizeof(struct sdca_fdl_file), GFP_KERNEL);
2087		if (!files)
2088			return -ENOMEM;
2089
2090		fileset_entries = kcalloc(num_entries, sizeof(u32), GFP_KERNEL);
2091		if (!fileset_entries)
2092			return -ENOMEM;
2093
2094		fwnode_property_read_u32_array(function_node, fileset_name,
2095					       fileset_entries, num_entries);
2096
2097		for (j = 0, num_files = 0; j < num_entries; num_files++) {
2098			struct sdca_fdl_file *file = &files[num_files];
2099
2100			file->vendor_id = fileset_entries[j++];
2101			file->file_id = fileset_entries[j++];
2102			file->fdl_offset = fileset_entries[j++];
2103
2104			dev_dbg(dev, "file: %#x, vendor: %#x, offset: %#x\n",
2105				file->file_id, file->vendor_id, file->fdl_offset);
2106		}
2107
2108		set->id = filesets_list[i];
2109		set->num_files = num_files;
2110		set->files = files;
2111	}
2112
2113	function->fdl_data.swft = sdw->sdca_data.swft;
2114	function->fdl_data.num_sets = num_sets;
2115	function->fdl_data.sets = sets;
2116
2117	return 0;
2118}
2119
2120/**
2121 * sdca_parse_function - parse ACPI DisCo for a Function
2122 * @dev: Pointer to device against which function data will be allocated.
2123 * @sdw: SoundWire slave device to be processed.
2124 * @function_desc: Pointer to the Function short descriptor.
2125 * @function: Pointer to the Function information, to be populated.
2126 *
2127 * Return: Returns 0 for success.
2128 */
2129int sdca_parse_function(struct device *dev, struct sdw_slave *sdw,
2130			struct sdca_function_desc *function_desc,
2131			struct sdca_function_data *function)
2132{
2133	u32 tmp;
2134	int ret;
2135
2136	function->desc = function_desc;
2137
2138	ret = fwnode_property_read_u32(function_desc->node,
2139				       "mipi-sdca-function-busy-max-delay", &tmp);
2140	if (!ret)
2141		function->busy_max_delay = tmp;
2142
2143	ret = fwnode_property_read_u32(function_desc->node,
2144				       "mipi-sdca-function-reset-max-delay", &tmp);
2145	if (!ret)
2146		function->reset_max_delay = tmp;
2147
2148	dev_dbg(dev, "%pfwP: name %s busy delay %dus reset delay %dus\n",
2149		function->desc->node, function->desc->name,
2150		function->busy_max_delay, function->reset_max_delay);
2151
2152	ret = find_sdca_init_table(dev, function_desc->node, function);
2153	if (ret)
2154		return ret;
2155
2156	ret = find_sdca_entities(dev, sdw, function_desc->node, function);
2157	if (ret)
2158		return ret;
2159
2160	ret = find_sdca_connections(dev, function_desc->node, function);
2161	if (ret)
2162		return ret;
2163
2164	ret = find_sdca_clusters(dev, function_desc->node, function);
2165	if (ret < 0)
2166		return ret;
2167
2168	ret = find_sdca_filesets(dev, sdw, function_desc->node, function);
2169	if (ret)
2170		return ret;
2171
2172	return 0;
2173}
2174EXPORT_SYMBOL_NS(sdca_parse_function, "SND_SOC_SDCA");
2175
2176const char *sdca_find_terminal_name(enum sdca_terminal_type type)
2177{
2178	switch (type) {
2179	case SDCA_TERM_TYPE_LINEIN_STEREO:
2180		return SDCA_TERM_TYPE_LINEIN_STEREO_NAME;
2181	case SDCA_TERM_TYPE_LINEIN_FRONT_LR:
2182		return SDCA_TERM_TYPE_LINEIN_FRONT_LR_NAME;
2183	case SDCA_TERM_TYPE_LINEIN_CENTER_LFE:
2184		return SDCA_TERM_TYPE_LINEIN_CENTER_LFE_NAME;
2185	case SDCA_TERM_TYPE_LINEIN_SURROUND_LR:
2186		return SDCA_TERM_TYPE_LINEIN_SURROUND_LR_NAME;
2187	case SDCA_TERM_TYPE_LINEIN_REAR_LR:
2188		return SDCA_TERM_TYPE_LINEIN_REAR_LR_NAME;
2189	case SDCA_TERM_TYPE_LINEOUT_STEREO:
2190		return SDCA_TERM_TYPE_LINEOUT_STEREO_NAME;
2191	case SDCA_TERM_TYPE_LINEOUT_FRONT_LR:
2192		return SDCA_TERM_TYPE_LINEOUT_FRONT_LR_NAME;
2193	case SDCA_TERM_TYPE_LINEOUT_CENTER_LFE:
2194		return SDCA_TERM_TYPE_LINEOUT_CENTER_LFE_NAME;
2195	case SDCA_TERM_TYPE_LINEOUT_SURROUND_LR:
2196		return SDCA_TERM_TYPE_LINEOUT_SURROUND_LR_NAME;
2197	case SDCA_TERM_TYPE_LINEOUT_REAR_LR:
2198		return SDCA_TERM_TYPE_LINEOUT_REAR_LR_NAME;
2199	case SDCA_TERM_TYPE_MIC_JACK:
2200		return SDCA_TERM_TYPE_MIC_JACK_NAME;
2201	case SDCA_TERM_TYPE_STEREO_JACK:
2202		return SDCA_TERM_TYPE_STEREO_JACK_NAME;
2203	case SDCA_TERM_TYPE_FRONT_LR_JACK:
2204		return SDCA_TERM_TYPE_FRONT_LR_JACK_NAME;
2205	case SDCA_TERM_TYPE_CENTER_LFE_JACK:
2206		return SDCA_TERM_TYPE_CENTER_LFE_JACK_NAME;
2207	case SDCA_TERM_TYPE_SURROUND_LR_JACK:
2208		return SDCA_TERM_TYPE_SURROUND_LR_JACK_NAME;
2209	case SDCA_TERM_TYPE_REAR_LR_JACK:
2210		return SDCA_TERM_TYPE_REAR_LR_JACK_NAME;
2211	case SDCA_TERM_TYPE_HEADPHONE_JACK:
2212		return SDCA_TERM_TYPE_HEADPHONE_JACK_NAME;
2213	case SDCA_TERM_TYPE_HEADSET_JACK:
2214		return SDCA_TERM_TYPE_HEADSET_JACK_NAME;
2215	default:
2216		return NULL;
2217	}
2218}
2219EXPORT_SYMBOL_NS(sdca_find_terminal_name, "SND_SOC_SDCA");
2220
2221struct sdca_control *sdca_selector_find_control(struct device *dev,
2222						struct sdca_entity *entity,
2223						const int sel)
2224{
2225	int i;
2226
2227	for (i = 0; i < entity->num_controls; i++) {
2228		struct sdca_control *control = &entity->controls[i];
2229
2230		if (control->sel == sel)
2231			return control;
2232	}
2233
2234	dev_err(dev, "%s: control %#x: missing\n", entity->label, sel);
2235	return NULL;
2236}
2237EXPORT_SYMBOL_NS(sdca_selector_find_control, "SND_SOC_SDCA");
2238
2239struct sdca_control_range *sdca_control_find_range(struct device *dev,
2240						   struct sdca_entity *entity,
2241						   struct sdca_control *control,
2242						   int cols, int rows)
2243{
2244	struct sdca_control_range *range = &control->range;
2245
2246	if ((cols && range->cols != cols) || (rows && range->rows != rows) ||
2247	    !range->data) {
2248		dev_err(dev, "%s: control %#x: ranges invalid (%d,%d)\n",
2249			entity->label, control->sel, range->cols, range->rows);
2250		return NULL;
2251	}
2252
2253	return range;
2254}
2255EXPORT_SYMBOL_NS(sdca_control_find_range, "SND_SOC_SDCA");
2256
2257struct sdca_control_range *sdca_selector_find_range(struct device *dev,
2258						    struct sdca_entity *entity,
2259						    int sel, int cols, int rows)
2260{
2261	struct sdca_control *control;
2262
2263	control = sdca_selector_find_control(dev, entity, sel);
2264	if (!control)
2265		return NULL;
2266
2267	return sdca_control_find_range(dev, entity, control, cols, rows);
2268}
2269EXPORT_SYMBOL_NS(sdca_selector_find_range, "SND_SOC_SDCA");
2270
2271struct sdca_cluster *sdca_id_find_cluster(struct device *dev,
2272					  struct sdca_function_data *function,
2273					  const int id)
2274{
2275	int i;
2276
2277	for (i = 0; i < function->num_clusters; i++) {
2278		struct sdca_cluster *cluster = &function->clusters[i];
2279
2280		if (cluster->id == id)
2281			return cluster;
2282	}
2283
2284	dev_err(dev, "%s: cluster %#x: missing\n", function->desc->name, id);
2285	return NULL;
2286}
2287EXPORT_SYMBOL_NS(sdca_id_find_cluster, "SND_SOC_SDCA");
2288
2289MODULE_LICENSE("Dual BSD/GPL");
2290MODULE_DESCRIPTION("SDCA library");