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