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

source code of linux/sound/soc/sdca/sdca_functions.c