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