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