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
patch_sdca_function_type(u32 interface_revision,u32 * function_type)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
get_sdca_function_name(u32 function_type)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
find_sdca_function(struct acpi_device * adev,void * data)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 */
sdca_lookup_functions(struct sdw_slave * slave)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
find_sdca_init_table(struct device * dev,struct fwnode_handle * function_node,struct sdca_function_data * function)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
find_sdca_control_label(struct device * dev,const struct sdca_entity * entity,const struct sdca_control * control)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
find_sdca_control_bits(const struct sdca_entity * entity,const struct sdca_control * control)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
find_sdca_control_datatype(const struct sdca_entity * entity,const struct sdca_control * control)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
find_sdca_control_range(struct device * dev,struct fwnode_handle * control_node,struct sdca_control_range * range)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
find_sdca_control_value(struct device * dev,struct sdca_entity * entity,struct fwnode_handle * control_node,struct sdca_control * control,const char * const label)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 */
find_sdca_entity_control(struct device * dev,struct sdca_entity * entity,struct fwnode_handle * control_node,struct sdca_control * control)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_kcalloc(dev, hweight64(control->cn_list),
898 sizeof(int), GFP_KERNEL);
899 if (!control->values)
900 return -ENOMEM;
901
902 switch (control->mode) {
903 case SDCA_ACCESS_MODE_DC:
904 ret = find_sdca_control_value(dev, entity, control_node, control,
905 "dc-value");
906 if (ret) {
907 dev_err(dev, "%s: control %#x: dc value missing: %d\n",
908 entity->label, control->sel, ret);
909 return ret;
910 }
911
912 control->has_fixed = true;
913 break;
914 case SDCA_ACCESS_MODE_RW:
915 case SDCA_ACCESS_MODE_DUAL:
916 ret = find_sdca_control_value(dev, entity, control_node, control,
917 "default-value");
918 if (!ret)
919 control->has_default = true;
920
921 ret = find_sdca_control_value(dev, entity, control_node, control,
922 "fixed-value");
923 if (!ret)
924 control->has_fixed = true;
925 fallthrough;
926 case SDCA_ACCESS_MODE_RO:
927 control->deferrable = fwnode_property_read_bool(control_node,
928 "mipi-sdca-control-deferrable");
929 break;
930 default:
931 break;
932 }
933
934 ret = find_sdca_control_range(dev, control_node, &control->range);
935 if (ret) {
936 dev_err(dev, "%s: control %#x: range missing: %d\n",
937 entity->label, control->sel, ret);
938 return ret;
939 }
940
941 ret = fwnode_property_read_u32(control_node,
942 "mipi-sdca-control-interrupt-position",
943 &tmp);
944 if (!ret)
945 control->interrupt_position = tmp;
946 else
947 control->interrupt_position = SDCA_NO_INTERRUPT;
948
949 control->label = find_sdca_control_label(dev, entity, control);
950 if (!control->label)
951 return -ENOMEM;
952
953 control->type = find_sdca_control_datatype(entity, control);
954 control->nbits = find_sdca_control_bits(entity, control);
955
956 dev_info(dev, "%s: %s: control %#x mode %#x layers %#x cn %#llx int %d %s\n",
957 entity->label, control->label, control->sel,
958 control->mode, control->layers, control->cn_list,
959 control->interrupt_position, control->deferrable ? "deferrable" : "");
960
961 return 0;
962 }
963
find_sdca_entity_controls(struct device * dev,struct fwnode_handle * entity_node,struct sdca_entity * entity)964 static int find_sdca_entity_controls(struct device *dev,
965 struct fwnode_handle *entity_node,
966 struct sdca_entity *entity)
967 {
968 struct sdca_control *controls;
969 int num_controls;
970 u64 control_list;
971 int control_sel;
972 int i, ret;
973
974 ret = fwnode_property_read_u64(entity_node, "mipi-sdca-control-list", &control_list);
975 if (ret == -EINVAL) {
976 /* Allow missing control lists, assume no controls. */
977 dev_warn(dev, "%s: missing control list\n", entity->label);
978 return 0;
979 } else if (ret) {
980 dev_err(dev, "%s: failed to read control list: %d\n", entity->label, ret);
981 return ret;
982 } else if (!control_list) {
983 return 0;
984 }
985
986 num_controls = hweight64(control_list);
987 controls = devm_kcalloc(dev, num_controls, sizeof(*controls), GFP_KERNEL);
988 if (!controls)
989 return -ENOMEM;
990
991 i = 0;
992 for_each_set_bit(control_sel, (unsigned long *)&control_list,
993 BITS_PER_TYPE(control_list)) {
994 struct fwnode_handle *control_node;
995 char control_property[SDCA_PROPERTY_LENGTH];
996
997 /* DisCo uses upper-case for hex numbers */
998 snprintf(control_property, sizeof(control_property),
999 "mipi-sdca-control-0x%X-subproperties", control_sel);
1000
1001 control_node = fwnode_get_named_child_node(entity_node, control_property);
1002 if (!control_node) {
1003 dev_err(dev, "%s: control node %s not found\n",
1004 entity->label, control_property);
1005 return -EINVAL;
1006 }
1007
1008 controls[i].sel = control_sel;
1009
1010 ret = find_sdca_entity_control(dev, entity, control_node, &controls[i]);
1011 fwnode_handle_put(control_node);
1012 if (ret)
1013 return ret;
1014
1015 i++;
1016 }
1017
1018 entity->num_controls = num_controls;
1019 entity->controls = controls;
1020
1021 return 0;
1022 }
1023
find_sdca_iot_dataport(struct sdca_entity_iot * terminal)1024 static bool find_sdca_iot_dataport(struct sdca_entity_iot *terminal)
1025 {
1026 switch (terminal->type) {
1027 case SDCA_TERM_TYPE_GENERIC:
1028 case SDCA_TERM_TYPE_ULTRASOUND:
1029 case SDCA_TERM_TYPE_CAPTURE_DIRECT_PCM_MIC:
1030 case SDCA_TERM_TYPE_RAW_PDM_MIC:
1031 case SDCA_TERM_TYPE_SPEECH:
1032 case SDCA_TERM_TYPE_VOICE:
1033 case SDCA_TERM_TYPE_SECONDARY_PCM_MIC:
1034 case SDCA_TERM_TYPE_ACOUSTIC_CONTEXT_AWARENESS:
1035 case SDCA_TERM_TYPE_DTOD_STREAM:
1036 case SDCA_TERM_TYPE_REFERENCE_STREAM:
1037 case SDCA_TERM_TYPE_SENSE_CAPTURE:
1038 case SDCA_TERM_TYPE_STREAMING_MIC:
1039 case SDCA_TERM_TYPE_OPTIMIZATION_STREAM:
1040 case SDCA_TERM_TYPE_PDM_RENDER_STREAM:
1041 case SDCA_TERM_TYPE_COMPANION_DATA:
1042 return true;
1043 default:
1044 return false;
1045 }
1046 }
1047
find_sdca_entity_iot(struct device * dev,struct fwnode_handle * entity_node,struct sdca_entity * entity)1048 static int find_sdca_entity_iot(struct device *dev,
1049 struct fwnode_handle *entity_node,
1050 struct sdca_entity *entity)
1051 {
1052 struct sdca_entity_iot *terminal = &entity->iot;
1053 u32 tmp;
1054 int ret;
1055
1056 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-terminal-type", &tmp);
1057 if (ret) {
1058 dev_err(dev, "%s: terminal type missing: %d\n", entity->label, ret);
1059 return ret;
1060 }
1061
1062 terminal->type = tmp;
1063 terminal->is_dataport = find_sdca_iot_dataport(terminal);
1064
1065 ret = fwnode_property_read_u32(entity_node,
1066 "mipi-sdca-terminal-reference-number", &tmp);
1067 if (!ret)
1068 terminal->reference = tmp;
1069
1070 ret = fwnode_property_read_u32(entity_node,
1071 "mipi-sdca-terminal-connector-type", &tmp);
1072 if (!ret)
1073 terminal->connector = tmp;
1074
1075 ret = fwnode_property_read_u32(entity_node,
1076 "mipi-sdca-terminal-transducer-count", &tmp);
1077 if (!ret)
1078 terminal->num_transducer = tmp;
1079
1080 dev_info(dev, "%s: terminal type %#x ref %#x conn %#x count %d\n",
1081 entity->label, terminal->type, terminal->reference,
1082 terminal->connector, terminal->num_transducer);
1083
1084 return 0;
1085 }
1086
find_sdca_entity_cs(struct device * dev,struct fwnode_handle * entity_node,struct sdca_entity * entity)1087 static int find_sdca_entity_cs(struct device *dev,
1088 struct fwnode_handle *entity_node,
1089 struct sdca_entity *entity)
1090 {
1091 struct sdca_entity_cs *clock = &entity->cs;
1092 u32 tmp;
1093 int ret;
1094
1095 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-cs-type", &tmp);
1096 if (ret) {
1097 dev_err(dev, "%s: clock type missing: %d\n", entity->label, ret);
1098 return ret;
1099 }
1100
1101 clock->type = tmp;
1102
1103 ret = fwnode_property_read_u32(entity_node,
1104 "mipi-sdca-clock-valid-max-delay", &tmp);
1105 if (!ret)
1106 clock->max_delay = tmp;
1107
1108 dev_info(dev, "%s: clock type %#x delay %d\n", entity->label,
1109 clock->type, clock->max_delay);
1110
1111 return 0;
1112 }
1113
find_sdca_entity_pde(struct device * dev,struct fwnode_handle * entity_node,struct sdca_entity * entity)1114 static int find_sdca_entity_pde(struct device *dev,
1115 struct fwnode_handle *entity_node,
1116 struct sdca_entity *entity)
1117 {
1118 static const int mult_delay = 3;
1119 struct sdca_entity_pde *power = &entity->pde;
1120 u32 *delay_list __free(kfree) = NULL;
1121 struct sdca_pde_delay *delays;
1122 int num_delays;
1123 int i, j;
1124
1125 num_delays = fwnode_property_count_u32(entity_node,
1126 "mipi-sdca-powerdomain-transition-max-delay");
1127 if (num_delays <= 0) {
1128 dev_err(dev, "%s: max delay list missing: %d\n",
1129 entity->label, num_delays);
1130 return -EINVAL;
1131 } else if (num_delays % mult_delay != 0) {
1132 dev_err(dev, "%s: delays not multiple of %d\n",
1133 entity->label, mult_delay);
1134 return -EINVAL;
1135 } else if (num_delays > SDCA_MAX_DELAY_COUNT) {
1136 dev_err(dev, "%s: maximum number of transition delays exceeded\n",
1137 entity->label);
1138 return -EINVAL;
1139 }
1140
1141 delay_list = kcalloc(num_delays, sizeof(*delay_list), GFP_KERNEL);
1142 if (!delay_list)
1143 return -ENOMEM;
1144
1145 fwnode_property_read_u32_array(entity_node,
1146 "mipi-sdca-powerdomain-transition-max-delay",
1147 delay_list, num_delays);
1148
1149 num_delays /= mult_delay;
1150
1151 delays = devm_kcalloc(dev, num_delays, sizeof(*delays), GFP_KERNEL);
1152 if (!delays)
1153 return -ENOMEM;
1154
1155 for (i = 0, j = 0; i < num_delays; i++) {
1156 delays[i].from_ps = delay_list[j++];
1157 delays[i].to_ps = delay_list[j++];
1158 delays[i].us = delay_list[j++];
1159
1160 dev_info(dev, "%s: from %#x to %#x delay %dus\n", entity->label,
1161 delays[i].from_ps, delays[i].to_ps, delays[i].us);
1162 }
1163
1164 power->num_max_delay = num_delays;
1165 power->max_delay = delays;
1166
1167 return 0;
1168 }
1169
1170 struct raw_ge_mode {
1171 u8 val;
1172 u8 num_controls;
1173 struct {
1174 u8 id;
1175 u8 sel;
1176 u8 cn;
1177 __le32 val;
1178 } __packed controls[] __counted_by(num_controls);
1179 } __packed;
1180
find_sdca_entity_ge(struct device * dev,struct fwnode_handle * entity_node,struct sdca_entity * entity)1181 static int find_sdca_entity_ge(struct device *dev,
1182 struct fwnode_handle *entity_node,
1183 struct sdca_entity *entity)
1184 {
1185 struct sdca_entity_ge *group = &entity->ge;
1186 u8 *affected_list __free(kfree) = NULL;
1187 u8 *affected_iter;
1188 int num_affected;
1189 int i, j;
1190
1191 num_affected = fwnode_property_count_u8(entity_node,
1192 "mipi-sdca-ge-selectedmode-controls-affected");
1193 if (!num_affected) {
1194 return 0;
1195 } else if (num_affected < 0) {
1196 dev_err(dev, "%s: failed to read affected controls: %d\n",
1197 entity->label, num_affected);
1198 return num_affected;
1199 } else if (num_affected > SDCA_MAX_AFFECTED_COUNT) {
1200 dev_err(dev, "%s: maximum affected controls size exceeded\n",
1201 entity->label);
1202 return -EINVAL;
1203 }
1204
1205 affected_list = kcalloc(num_affected, sizeof(*affected_list), GFP_KERNEL);
1206 if (!affected_list)
1207 return -ENOMEM;
1208
1209 fwnode_property_read_u8_array(entity_node,
1210 "mipi-sdca-ge-selectedmode-controls-affected",
1211 affected_list, num_affected);
1212
1213 group->num_modes = *affected_list;
1214 affected_iter = affected_list + 1;
1215
1216 group->modes = devm_kcalloc(dev, group->num_modes, sizeof(*group->modes),
1217 GFP_KERNEL);
1218 if (!group->modes)
1219 return -ENOMEM;
1220
1221 for (i = 0; i < group->num_modes; i++) {
1222 struct raw_ge_mode *raw = (struct raw_ge_mode *)affected_iter;
1223 struct sdca_ge_mode *mode = &group->modes[i];
1224
1225 affected_iter += sizeof(*raw);
1226 if (affected_iter > affected_list + num_affected)
1227 goto bad_list;
1228
1229 mode->val = raw->val;
1230 mode->num_controls = raw->num_controls;
1231
1232 affected_iter += mode->num_controls * sizeof(raw->controls[0]);
1233 if (affected_iter > affected_list + num_affected)
1234 goto bad_list;
1235
1236 mode->controls = devm_kcalloc(dev, mode->num_controls,
1237 sizeof(*mode->controls), GFP_KERNEL);
1238 if (!mode->controls)
1239 return -ENOMEM;
1240
1241 for (j = 0; j < mode->num_controls; j++) {
1242 mode->controls[j].id = raw->controls[j].id;
1243 mode->controls[j].sel = raw->controls[j].sel;
1244 mode->controls[j].cn = raw->controls[j].cn;
1245 mode->controls[j].val = le32_to_cpu(raw->controls[j].val);
1246 }
1247 }
1248
1249 return 0;
1250
1251 bad_list:
1252 dev_err(dev, "%s: malformed affected controls list\n", entity->label);
1253 return -EINVAL;
1254 }
1255
1256 static int
find_sdca_entity_hide(struct device * dev,struct fwnode_handle * function_node,struct fwnode_handle * entity_node,struct sdca_entity * entity)1257 find_sdca_entity_hide(struct device *dev, struct fwnode_handle *function_node,
1258 struct fwnode_handle *entity_node, struct sdca_entity *entity)
1259 {
1260 struct sdca_entity_hide *hide = &entity->hide;
1261 unsigned int delay, *af_list = hide->af_number_list;
1262 int nval, ret;
1263 unsigned char *report_desc = NULL;
1264
1265 ret = fwnode_property_read_u32(entity_node,
1266 "mipi-sdca-RxUMP-ownership-transition-maxdelay", &delay);
1267 if (!ret)
1268 hide->max_delay = delay;
1269
1270 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDTx-supported-report-ids");
1271 if (nval > 0) {
1272 hide->num_hidtx_ids = nval;
1273 hide->hidtx_ids = devm_kcalloc(dev, hide->num_hidtx_ids,
1274 sizeof(*hide->hidtx_ids), GFP_KERNEL);
1275 if (!hide->hidtx_ids)
1276 return -ENOMEM;
1277
1278 ret = fwnode_property_read_u32_array(entity_node,
1279 "mipi-sdca-HIDTx-supported-report-ids",
1280 hide->hidtx_ids,
1281 hide->num_hidtx_ids);
1282 if (ret < 0)
1283 return ret;
1284 }
1285
1286 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDRx-supported-report-ids");
1287 if (nval > 0) {
1288 hide->num_hidrx_ids = nval;
1289 hide->hidrx_ids = devm_kcalloc(dev, hide->num_hidrx_ids,
1290 sizeof(*hide->hidrx_ids), GFP_KERNEL);
1291 if (!hide->hidrx_ids)
1292 return -ENOMEM;
1293
1294 ret = fwnode_property_read_u32_array(entity_node,
1295 "mipi-sdca-HIDRx-supported-report-ids",
1296 hide->hidrx_ids,
1297 hide->num_hidrx_ids);
1298 if (ret < 0)
1299 return ret;
1300 }
1301
1302 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-hide-related-audio-function-list");
1303 if (nval <= 0) {
1304 dev_err(dev, "%pfwP: audio function numbers list missing: %d\n",
1305 entity_node, nval);
1306 return -EINVAL;
1307 } else if (nval > SDCA_MAX_FUNCTION_COUNT) {
1308 dev_err(dev, "%pfwP: maximum number of audio function exceeded\n", entity_node);
1309 return -EINVAL;
1310 }
1311
1312 hide->hide_reside_function_num = nval;
1313 fwnode_property_read_u32_array(entity_node,
1314 "mipi-sdca-hide-related-audio-function-list", af_list, nval);
1315
1316 nval = fwnode_property_count_u8(function_node, "mipi-sdca-hid-descriptor");
1317 if (nval)
1318 fwnode_property_read_u8_array(function_node, "mipi-sdca-hid-descriptor",
1319 (u8 *)&hide->hid_desc, nval);
1320
1321 if (hide->hid_desc.bNumDescriptors) {
1322 nval = fwnode_property_count_u8(function_node, "mipi-sdca-report-descriptor");
1323 if (nval) {
1324 report_desc = devm_kzalloc(dev, nval, GFP_KERNEL);
1325 if (!report_desc)
1326 return -ENOMEM;
1327 hide->hid_report_desc = report_desc;
1328 fwnode_property_read_u8_array(function_node, "mipi-sdca-report-descriptor",
1329 report_desc, nval);
1330
1331 /* add HID device */
1332 ret = sdca_add_hid_device(dev, entity);
1333 if (ret) {
1334 dev_err(dev, "%pfwP: failed to add HID device: %d\n", entity_node, ret);
1335 return ret;
1336 }
1337 }
1338 }
1339
1340 return 0;
1341 }
1342
find_sdca_entity(struct device * dev,struct fwnode_handle * function_node,struct fwnode_handle * entity_node,struct sdca_entity * entity)1343 static int find_sdca_entity(struct device *dev,
1344 struct fwnode_handle *function_node,
1345 struct fwnode_handle *entity_node,
1346 struct sdca_entity *entity)
1347 {
1348 u32 tmp;
1349 int ret;
1350
1351 ret = fwnode_property_read_string(entity_node, "mipi-sdca-entity-label",
1352 &entity->label);
1353 if (ret) {
1354 dev_err(dev, "%pfwP: entity %#x: label missing: %d\n",
1355 function_node, entity->id, ret);
1356 return ret;
1357 }
1358
1359 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-entity-type", &tmp);
1360 if (ret) {
1361 dev_err(dev, "%s: type missing: %d\n", entity->label, ret);
1362 return ret;
1363 }
1364
1365 entity->type = tmp;
1366
1367 dev_info(dev, "%s: entity %#x type %#x\n",
1368 entity->label, entity->id, entity->type);
1369
1370 switch (entity->type) {
1371 case SDCA_ENTITY_TYPE_IT:
1372 case SDCA_ENTITY_TYPE_OT:
1373 ret = find_sdca_entity_iot(dev, entity_node, entity);
1374 break;
1375 case SDCA_ENTITY_TYPE_CS:
1376 ret = find_sdca_entity_cs(dev, entity_node, entity);
1377 break;
1378 case SDCA_ENTITY_TYPE_PDE:
1379 ret = find_sdca_entity_pde(dev, entity_node, entity);
1380 break;
1381 case SDCA_ENTITY_TYPE_GE:
1382 ret = find_sdca_entity_ge(dev, entity_node, entity);
1383 break;
1384 case SDCA_ENTITY_TYPE_HIDE:
1385 ret = find_sdca_entity_hide(dev, function_node, entity_node, entity);
1386 break;
1387 default:
1388 break;
1389 }
1390 if (ret)
1391 return ret;
1392
1393 ret = find_sdca_entity_controls(dev, entity_node, entity);
1394 if (ret)
1395 return ret;
1396
1397 return 0;
1398 }
1399
find_sdca_entities(struct device * dev,struct fwnode_handle * function_node,struct sdca_function_data * function)1400 static int find_sdca_entities(struct device *dev,
1401 struct fwnode_handle *function_node,
1402 struct sdca_function_data *function)
1403 {
1404 u32 *entity_list __free(kfree) = NULL;
1405 struct sdca_entity *entities;
1406 int num_entities;
1407 int i, ret;
1408
1409 num_entities = fwnode_property_count_u32(function_node,
1410 "mipi-sdca-entity-id-list");
1411 if (num_entities <= 0) {
1412 dev_err(dev, "%pfwP: entity id list missing: %d\n",
1413 function_node, num_entities);
1414 return -EINVAL;
1415 } else if (num_entities > SDCA_MAX_ENTITY_COUNT) {
1416 dev_err(dev, "%pfwP: maximum number of entities exceeded\n",
1417 function_node);
1418 return -EINVAL;
1419 }
1420
1421 /* Add 1 to make space for Entity 0 */
1422 entities = devm_kcalloc(dev, num_entities + 1, sizeof(*entities), GFP_KERNEL);
1423 if (!entities)
1424 return -ENOMEM;
1425
1426 entity_list = kcalloc(num_entities, sizeof(*entity_list), GFP_KERNEL);
1427 if (!entity_list)
1428 return -ENOMEM;
1429
1430 fwnode_property_read_u32_array(function_node, "mipi-sdca-entity-id-list",
1431 entity_list, num_entities);
1432
1433 for (i = 0; i < num_entities; i++)
1434 entities[i].id = entity_list[i];
1435
1436 /* now read subproperties */
1437 for (i = 0; i < num_entities; i++) {
1438 char entity_property[SDCA_PROPERTY_LENGTH];
1439 struct fwnode_handle *entity_node;
1440
1441 /* DisCo uses upper-case for hex numbers */
1442 snprintf(entity_property, sizeof(entity_property),
1443 "mipi-sdca-entity-id-0x%X-subproperties", entities[i].id);
1444
1445 entity_node = fwnode_get_named_child_node(function_node, entity_property);
1446 if (!entity_node) {
1447 dev_err(dev, "%pfwP: entity node %s not found\n",
1448 function_node, entity_property);
1449 return -EINVAL;
1450 }
1451
1452 ret = find_sdca_entity(dev, function_node, entity_node, &entities[i]);
1453 fwnode_handle_put(entity_node);
1454 if (ret)
1455 return ret;
1456 }
1457
1458 /*
1459 * Add Entity 0 at end of the array, makes it easy to skip during
1460 * all the Entity searches involved in creating connections.
1461 */
1462 entities[num_entities].label = "entity0";
1463
1464 ret = find_sdca_entity_controls(dev, function_node, &entities[num_entities]);
1465 if (ret)
1466 return ret;
1467
1468 function->num_entities = num_entities + 1;
1469 function->entities = entities;
1470
1471 return 0;
1472 }
1473
find_sdca_entity_by_label(struct sdca_function_data * function,const char * entity_label)1474 static struct sdca_entity *find_sdca_entity_by_label(struct sdca_function_data *function,
1475 const char *entity_label)
1476 {
1477 int i;
1478
1479 for (i = 0; i < function->num_entities; i++) {
1480 struct sdca_entity *entity = &function->entities[i];
1481
1482 if (!strcmp(entity->label, entity_label))
1483 return entity;
1484 }
1485
1486 return NULL;
1487 }
1488
find_sdca_entity_by_id(struct sdca_function_data * function,const int id)1489 static struct sdca_entity *find_sdca_entity_by_id(struct sdca_function_data *function,
1490 const int id)
1491 {
1492 int i;
1493
1494 for (i = 0; i < function->num_entities; i++) {
1495 struct sdca_entity *entity = &function->entities[i];
1496
1497 if (entity->id == id)
1498 return entity;
1499 }
1500
1501 return NULL;
1502 }
1503
find_sdca_entity_connection_iot(struct device * dev,struct sdca_function_data * function,struct fwnode_handle * entity_node,struct sdca_entity * entity)1504 static int find_sdca_entity_connection_iot(struct device *dev,
1505 struct sdca_function_data *function,
1506 struct fwnode_handle *entity_node,
1507 struct sdca_entity *entity)
1508 {
1509 struct sdca_entity_iot *terminal = &entity->iot;
1510 struct fwnode_handle *clock_node;
1511 struct sdca_entity *clock_entity;
1512 const char *clock_label;
1513 int ret;
1514
1515 clock_node = fwnode_get_named_child_node(entity_node,
1516 "mipi-sdca-terminal-clock-connection");
1517 if (!clock_node)
1518 return 0;
1519
1520 ret = fwnode_property_read_string(clock_node, "mipi-sdca-entity-label",
1521 &clock_label);
1522 if (ret) {
1523 dev_err(dev, "%s: clock label missing: %d\n", entity->label, ret);
1524 fwnode_handle_put(clock_node);
1525 return ret;
1526 }
1527
1528 clock_entity = find_sdca_entity_by_label(function, clock_label);
1529 if (!clock_entity) {
1530 dev_err(dev, "%s: failed to find clock with label %s\n",
1531 entity->label, clock_label);
1532 fwnode_handle_put(clock_node);
1533 return -EINVAL;
1534 }
1535
1536 terminal->clock = clock_entity;
1537
1538 dev_info(dev, "%s -> %s\n", clock_entity->label, entity->label);
1539
1540 fwnode_handle_put(clock_node);
1541 return 0;
1542 }
1543
find_sdca_entity_connection_pde(struct device * dev,struct sdca_function_data * function,struct fwnode_handle * entity_node,struct sdca_entity * entity)1544 static int find_sdca_entity_connection_pde(struct device *dev,
1545 struct sdca_function_data *function,
1546 struct fwnode_handle *entity_node,
1547 struct sdca_entity *entity)
1548 {
1549 struct sdca_entity_pde *power = &entity->pde;
1550 u32 *managed_list __free(kfree) = NULL;
1551 struct sdca_entity **managed;
1552 int num_managed;
1553 int i;
1554
1555 num_managed = fwnode_property_count_u32(entity_node,
1556 "mipi-sdca-powerdomain-managed-list");
1557 if (!num_managed) {
1558 return 0;
1559 } else if (num_managed < 0) {
1560 dev_err(dev, "%s: managed list missing: %d\n", entity->label, num_managed);
1561 return num_managed;
1562 } else if (num_managed > SDCA_MAX_ENTITY_COUNT) {
1563 dev_err(dev, "%s: maximum number of managed entities exceeded\n",
1564 entity->label);
1565 return -EINVAL;
1566 }
1567
1568 managed = devm_kcalloc(dev, num_managed, sizeof(*managed), GFP_KERNEL);
1569 if (!managed)
1570 return -ENOMEM;
1571
1572 managed_list = kcalloc(num_managed, sizeof(*managed_list), GFP_KERNEL);
1573 if (!managed_list)
1574 return -ENOMEM;
1575
1576 fwnode_property_read_u32_array(entity_node,
1577 "mipi-sdca-powerdomain-managed-list",
1578 managed_list, num_managed);
1579
1580 for (i = 0; i < num_managed; i++) {
1581 managed[i] = find_sdca_entity_by_id(function, managed_list[i]);
1582 if (!managed[i]) {
1583 dev_err(dev, "%s: failed to find entity with id %#x\n",
1584 entity->label, managed_list[i]);
1585 return -EINVAL;
1586 }
1587
1588 dev_info(dev, "%s -> %s\n", managed[i]->label, entity->label);
1589 }
1590
1591 power->num_managed = num_managed;
1592 power->managed = managed;
1593
1594 return 0;
1595 }
1596
find_sdca_entity_connection_ge(struct device * dev,struct sdca_function_data * function,struct fwnode_handle * entity_node,struct sdca_entity * entity)1597 static int find_sdca_entity_connection_ge(struct device *dev,
1598 struct sdca_function_data *function,
1599 struct fwnode_handle *entity_node,
1600 struct sdca_entity *entity)
1601 {
1602 int i, j;
1603
1604 for (i = 0; i < entity->ge.num_modes; i++) {
1605 struct sdca_ge_mode *mode = &entity->ge.modes[i];
1606
1607 for (j = 0; j < mode->num_controls; j++) {
1608 struct sdca_ge_control *affected = &mode->controls[j];
1609 struct sdca_entity *managed;
1610
1611 managed = find_sdca_entity_by_id(function, affected->id);
1612 if (!managed) {
1613 dev_err(dev, "%s: failed to find entity with id %#x\n",
1614 entity->label, affected->id);
1615 return -EINVAL;
1616 }
1617
1618 if (managed->group && managed->group != entity) {
1619 dev_err(dev,
1620 "%s: entity controlled by two groups %s, %s\n",
1621 managed->label, managed->group->label,
1622 entity->label);
1623 return -EINVAL;
1624 }
1625
1626 managed->group = entity;
1627 }
1628 }
1629
1630 return 0;
1631 }
1632
find_sdca_entity_connection(struct device * dev,struct sdca_function_data * function,struct fwnode_handle * entity_node,struct sdca_entity * entity)1633 static int find_sdca_entity_connection(struct device *dev,
1634 struct sdca_function_data *function,
1635 struct fwnode_handle *entity_node,
1636 struct sdca_entity *entity)
1637 {
1638 struct sdca_entity **pins;
1639 int num_pins, pin;
1640 u64 pin_list;
1641 int i, ret;
1642
1643 switch (entity->type) {
1644 case SDCA_ENTITY_TYPE_IT:
1645 case SDCA_ENTITY_TYPE_OT:
1646 ret = find_sdca_entity_connection_iot(dev, function,
1647 entity_node, entity);
1648 break;
1649 case SDCA_ENTITY_TYPE_PDE:
1650 ret = find_sdca_entity_connection_pde(dev, function,
1651 entity_node, entity);
1652 break;
1653 case SDCA_ENTITY_TYPE_GE:
1654 ret = find_sdca_entity_connection_ge(dev, function,
1655 entity_node, entity);
1656 break;
1657 default:
1658 ret = 0;
1659 break;
1660 }
1661 if (ret)
1662 return ret;
1663
1664 ret = fwnode_property_read_u64(entity_node, "mipi-sdca-input-pin-list", &pin_list);
1665 if (ret == -EINVAL) {
1666 /* Allow missing pin lists, assume no pins. */
1667 return 0;
1668 } else if (ret) {
1669 dev_err(dev, "%s: failed to read pin list: %d\n", entity->label, ret);
1670 return ret;
1671 } else if (pin_list & BIT(0)) {
1672 /*
1673 * Each bit set in the pin-list refers to an entity_id in this
1674 * Function. Entity 0 is an illegal connection since it is used
1675 * for Function-level configurations.
1676 */
1677 dev_err(dev, "%s: pin 0 used as input\n", entity->label);
1678 return -EINVAL;
1679 } else if (!pin_list) {
1680 return 0;
1681 }
1682
1683 num_pins = hweight64(pin_list);
1684 pins = devm_kcalloc(dev, num_pins, sizeof(*pins), GFP_KERNEL);
1685 if (!pins)
1686 return -ENOMEM;
1687
1688 i = 0;
1689 for_each_set_bit(pin, (unsigned long *)&pin_list, BITS_PER_TYPE(pin_list)) {
1690 char pin_property[SDCA_PROPERTY_LENGTH];
1691 struct fwnode_handle *connected_node;
1692 struct sdca_entity *connected_entity;
1693 const char *connected_label;
1694
1695 snprintf(pin_property, sizeof(pin_property), "mipi-sdca-input-pin-%d", pin);
1696
1697 connected_node = fwnode_get_named_child_node(entity_node, pin_property);
1698 if (!connected_node) {
1699 dev_err(dev, "%s: pin node %s not found\n",
1700 entity->label, pin_property);
1701 return -EINVAL;
1702 }
1703
1704 ret = fwnode_property_read_string(connected_node, "mipi-sdca-entity-label",
1705 &connected_label);
1706 if (ret) {
1707 dev_err(dev, "%s: pin %d label missing: %d\n",
1708 entity->label, pin, ret);
1709 fwnode_handle_put(connected_node);
1710 return ret;
1711 }
1712
1713 connected_entity = find_sdca_entity_by_label(function, connected_label);
1714 if (!connected_entity) {
1715 dev_err(dev, "%s: failed to find entity with label %s\n",
1716 entity->label, connected_label);
1717 fwnode_handle_put(connected_node);
1718 return -EINVAL;
1719 }
1720
1721 pins[i] = connected_entity;
1722
1723 dev_info(dev, "%s -> %s\n", connected_entity->label, entity->label);
1724
1725 i++;
1726 fwnode_handle_put(connected_node);
1727 }
1728
1729 entity->num_sources = num_pins;
1730 entity->sources = pins;
1731
1732 return 0;
1733 }
1734
find_sdca_connections(struct device * dev,struct fwnode_handle * function_node,struct sdca_function_data * function)1735 static int find_sdca_connections(struct device *dev,
1736 struct fwnode_handle *function_node,
1737 struct sdca_function_data *function)
1738 {
1739 int i;
1740
1741 /* Entity 0 cannot have connections */
1742 for (i = 0; i < function->num_entities - 1; i++) {
1743 struct sdca_entity *entity = &function->entities[i];
1744 char entity_property[SDCA_PROPERTY_LENGTH];
1745 struct fwnode_handle *entity_node;
1746 int ret;
1747
1748 /* DisCo uses upper-case for hex numbers */
1749 snprintf(entity_property, sizeof(entity_property),
1750 "mipi-sdca-entity-id-0x%X-subproperties",
1751 entity->id);
1752
1753 entity_node = fwnode_get_named_child_node(function_node, entity_property);
1754 if (!entity_node) {
1755 dev_err(dev, "%pfwP: entity node %s not found\n",
1756 function_node, entity_property);
1757 return -EINVAL;
1758 }
1759
1760 ret = find_sdca_entity_connection(dev, function, entity_node, entity);
1761 fwnode_handle_put(entity_node);
1762 if (ret)
1763 return ret;
1764 }
1765
1766 return 0;
1767 }
1768
find_sdca_cluster_channel(struct device * dev,struct sdca_cluster * cluster,struct fwnode_handle * channel_node,struct sdca_channel * channel)1769 static int find_sdca_cluster_channel(struct device *dev,
1770 struct sdca_cluster *cluster,
1771 struct fwnode_handle *channel_node,
1772 struct sdca_channel *channel)
1773 {
1774 u32 tmp;
1775 int ret;
1776
1777 ret = fwnode_property_read_u32(channel_node, "mipi-sdca-cluster-channel-id", &tmp);
1778 if (ret) {
1779 dev_err(dev, "cluster %#x: missing channel id: %d\n",
1780 cluster->id, ret);
1781 return ret;
1782 }
1783
1784 channel->id = tmp;
1785
1786 ret = fwnode_property_read_u32(channel_node,
1787 "mipi-sdca-cluster-channel-purpose",
1788 &tmp);
1789 if (ret) {
1790 dev_err(dev, "cluster %#x: channel %#x: missing purpose: %d\n",
1791 cluster->id, channel->id, ret);
1792 return ret;
1793 }
1794
1795 channel->purpose = tmp;
1796
1797 ret = fwnode_property_read_u32(channel_node,
1798 "mipi-sdca-cluster-channel-relationship",
1799 &tmp);
1800 if (ret) {
1801 dev_err(dev, "cluster %#x: channel %#x: missing relationship: %d\n",
1802 cluster->id, channel->id, ret);
1803 return ret;
1804 }
1805
1806 channel->relationship = tmp;
1807
1808 dev_info(dev, "cluster %#x: channel id %#x purpose %#x relationship %#x\n",
1809 cluster->id, channel->id, channel->purpose, channel->relationship);
1810
1811 return 0;
1812 }
1813
find_sdca_cluster_channels(struct device * dev,struct fwnode_handle * cluster_node,struct sdca_cluster * cluster)1814 static int find_sdca_cluster_channels(struct device *dev,
1815 struct fwnode_handle *cluster_node,
1816 struct sdca_cluster *cluster)
1817 {
1818 struct sdca_channel *channels;
1819 u32 num_channels;
1820 int i, ret;
1821
1822 ret = fwnode_property_read_u32(cluster_node, "mipi-sdca-channel-count",
1823 &num_channels);
1824 if (ret < 0) {
1825 dev_err(dev, "cluster %#x: failed to read channel list: %d\n",
1826 cluster->id, ret);
1827 return ret;
1828 } else if (num_channels > SDCA_MAX_CHANNEL_COUNT) {
1829 dev_err(dev, "cluster %#x: maximum number of channels exceeded\n",
1830 cluster->id);
1831 return -EINVAL;
1832 }
1833
1834 channels = devm_kcalloc(dev, num_channels, sizeof(*channels), GFP_KERNEL);
1835 if (!channels)
1836 return -ENOMEM;
1837
1838 for (i = 0; i < num_channels; i++) {
1839 char channel_property[SDCA_PROPERTY_LENGTH];
1840 struct fwnode_handle *channel_node;
1841
1842 /* DisCo uses upper-case for hex numbers */
1843 snprintf(channel_property, sizeof(channel_property),
1844 "mipi-sdca-channel-%d-subproperties", i + 1);
1845
1846 channel_node = fwnode_get_named_child_node(cluster_node, channel_property);
1847 if (!channel_node) {
1848 dev_err(dev, "cluster %#x: channel node %s not found\n",
1849 cluster->id, channel_property);
1850 return -EINVAL;
1851 }
1852
1853 ret = find_sdca_cluster_channel(dev, cluster, channel_node, &channels[i]);
1854 fwnode_handle_put(channel_node);
1855 if (ret)
1856 return ret;
1857 }
1858
1859 cluster->num_channels = num_channels;
1860 cluster->channels = channels;
1861
1862 return 0;
1863 }
1864
find_sdca_clusters(struct device * dev,struct fwnode_handle * function_node,struct sdca_function_data * function)1865 static int find_sdca_clusters(struct device *dev,
1866 struct fwnode_handle *function_node,
1867 struct sdca_function_data *function)
1868 {
1869 u32 *cluster_list __free(kfree) = NULL;
1870 struct sdca_cluster *clusters;
1871 int num_clusters;
1872 int i, ret;
1873
1874 num_clusters = fwnode_property_count_u32(function_node, "mipi-sdca-cluster-id-list");
1875 if (!num_clusters || num_clusters == -EINVAL) {
1876 return 0;
1877 } else if (num_clusters < 0) {
1878 dev_err(dev, "%pfwP: failed to read cluster id list: %d\n",
1879 function_node, num_clusters);
1880 return num_clusters;
1881 } else if (num_clusters > SDCA_MAX_CLUSTER_COUNT) {
1882 dev_err(dev, "%pfwP: maximum number of clusters exceeded\n", function_node);
1883 return -EINVAL;
1884 }
1885
1886 clusters = devm_kcalloc(dev, num_clusters, sizeof(*clusters), GFP_KERNEL);
1887 if (!clusters)
1888 return -ENOMEM;
1889
1890 cluster_list = kcalloc(num_clusters, sizeof(*cluster_list), GFP_KERNEL);
1891 if (!cluster_list)
1892 return -ENOMEM;
1893
1894 fwnode_property_read_u32_array(function_node, "mipi-sdca-cluster-id-list",
1895 cluster_list, num_clusters);
1896
1897 for (i = 0; i < num_clusters; i++)
1898 clusters[i].id = cluster_list[i];
1899
1900 /* now read subproperties */
1901 for (i = 0; i < num_clusters; i++) {
1902 char cluster_property[SDCA_PROPERTY_LENGTH];
1903 struct fwnode_handle *cluster_node;
1904
1905 /* DisCo uses upper-case for hex numbers */
1906 snprintf(cluster_property, sizeof(cluster_property),
1907 "mipi-sdca-cluster-id-0x%X-subproperties", clusters[i].id);
1908
1909 cluster_node = fwnode_get_named_child_node(function_node, cluster_property);
1910 if (!cluster_node) {
1911 dev_err(dev, "%pfwP: cluster node %s not found\n",
1912 function_node, cluster_property);
1913 return -EINVAL;
1914 }
1915
1916 ret = find_sdca_cluster_channels(dev, cluster_node, &clusters[i]);
1917 fwnode_handle_put(cluster_node);
1918 if (ret)
1919 return ret;
1920 }
1921
1922 function->num_clusters = num_clusters;
1923 function->clusters = clusters;
1924
1925 return 0;
1926 }
1927
1928 /**
1929 * sdca_parse_function - parse ACPI DisCo for a Function
1930 * @dev: Pointer to device against which function data will be allocated.
1931 * @function_desc: Pointer to the Function short descriptor.
1932 * @function: Pointer to the Function information, to be populated.
1933 *
1934 * Return: Returns 0 for success.
1935 */
sdca_parse_function(struct device * dev,struct sdca_function_desc * function_desc,struct sdca_function_data * function)1936 int sdca_parse_function(struct device *dev,
1937 struct sdca_function_desc *function_desc,
1938 struct sdca_function_data *function)
1939 {
1940 u32 tmp;
1941 int ret;
1942
1943 function->desc = function_desc;
1944
1945 ret = fwnode_property_read_u32(function_desc->node,
1946 "mipi-sdca-function-busy-max-delay", &tmp);
1947 if (!ret)
1948 function->busy_max_delay = tmp;
1949
1950 dev_info(dev, "%pfwP: name %s delay %dus\n", function->desc->node,
1951 function->desc->name, function->busy_max_delay);
1952
1953 ret = find_sdca_init_table(dev, function_desc->node, function);
1954 if (ret)
1955 return ret;
1956
1957 ret = find_sdca_entities(dev, function_desc->node, function);
1958 if (ret)
1959 return ret;
1960
1961 ret = find_sdca_connections(dev, function_desc->node, function);
1962 if (ret)
1963 return ret;
1964
1965 ret = find_sdca_clusters(dev, function_desc->node, function);
1966 if (ret < 0)
1967 return ret;
1968
1969 return 0;
1970 }
1971 EXPORT_SYMBOL_NS(sdca_parse_function, "SND_SOC_SDCA");
1972
sdca_selector_find_control(struct device * dev,struct sdca_entity * entity,const int sel)1973 struct sdca_control *sdca_selector_find_control(struct device *dev,
1974 struct sdca_entity *entity,
1975 const int sel)
1976 {
1977 int i;
1978
1979 for (i = 0; i < entity->num_controls; i++) {
1980 struct sdca_control *control = &entity->controls[i];
1981
1982 if (control->sel == sel)
1983 return control;
1984 }
1985
1986 dev_err(dev, "%s: control %#x: missing\n", entity->label, sel);
1987 return NULL;
1988 }
1989 EXPORT_SYMBOL_NS(sdca_selector_find_control, "SND_SOC_SDCA");
1990
sdca_control_find_range(struct device * dev,struct sdca_entity * entity,struct sdca_control * control,int cols,int rows)1991 struct sdca_control_range *sdca_control_find_range(struct device *dev,
1992 struct sdca_entity *entity,
1993 struct sdca_control *control,
1994 int cols, int rows)
1995 {
1996 struct sdca_control_range *range = &control->range;
1997
1998 if ((cols && range->cols != cols) || (rows && range->rows != rows) ||
1999 !range->data) {
2000 dev_err(dev, "%s: control %#x: ranges invalid (%d,%d)\n",
2001 entity->label, control->sel, range->cols, range->rows);
2002 return NULL;
2003 }
2004
2005 return range;
2006 }
2007 EXPORT_SYMBOL_NS(sdca_control_find_range, "SND_SOC_SDCA");
2008
sdca_selector_find_range(struct device * dev,struct sdca_entity * entity,int sel,int cols,int rows)2009 struct sdca_control_range *sdca_selector_find_range(struct device *dev,
2010 struct sdca_entity *entity,
2011 int sel, int cols, int rows)
2012 {
2013 struct sdca_control *control;
2014
2015 control = sdca_selector_find_control(dev, entity, sel);
2016 if (!control)
2017 return NULL;
2018
2019 return sdca_control_find_range(dev, entity, control, cols, rows);
2020 }
2021 EXPORT_SYMBOL_NS(sdca_selector_find_range, "SND_SOC_SDCA");
2022
sdca_id_find_cluster(struct device * dev,struct sdca_function_data * function,const int id)2023 struct sdca_cluster *sdca_id_find_cluster(struct device *dev,
2024 struct sdca_function_data *function,
2025 const int id)
2026 {
2027 int i;
2028
2029 for (i = 0; i < function->num_clusters; i++) {
2030 struct sdca_cluster *cluster = &function->clusters[i];
2031
2032 if (cluster->id == id)
2033 return cluster;
2034 }
2035
2036 dev_err(dev, "%s: cluster %#x: missing\n", function->desc->name, id);
2037 return NULL;
2038 }
2039 EXPORT_SYMBOL_NS(sdca_id_find_cluster, "SND_SOC_SDCA");
2040
2041 MODULE_LICENSE("Dual BSD/GPL");
2042 MODULE_DESCRIPTION("SDCA library");
2043