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