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