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 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 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 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 */ 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 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 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 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 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 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 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 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 914 /* 915 * TODO: Add support for -cn- properties, allowing different channels to have 916 * different defaults etc. 917 */ 918 static int find_sdca_entity_control(struct device *dev, struct sdca_entity *entity, 919 struct fwnode_handle *control_node, 920 struct sdca_control *control) 921 { 922 u32 tmp; 923 int ret; 924 925 ret = fwnode_property_read_u32(control_node, "mipi-sdca-control-access-mode", &tmp); 926 if (ret) { 927 dev_err(dev, "%s: control %#x: access mode missing: %d\n", 928 entity->label, control->sel, ret); 929 return ret; 930 } 931 932 control->mode = tmp; 933 934 ret = fwnode_property_read_u32(control_node, "mipi-sdca-control-access-layer", &tmp); 935 if (ret) { 936 dev_err(dev, "%s: control %#x: access layer missing: %d\n", 937 entity->label, control->sel, ret); 938 return ret; 939 } 940 941 control->layers = tmp; 942 943 ret = fwnode_property_read_u64(control_node, "mipi-sdca-control-cn-list", 944 &control->cn_list); 945 if (ret == -EINVAL) { 946 /* Spec allows not specifying cn-list if only the first number is used */ 947 control->cn_list = 0x1; 948 } else if (ret || !control->cn_list) { 949 dev_err(dev, "%s: control %#x: cn list missing: %d\n", 950 entity->label, control->sel, ret); 951 return ret; 952 } 953 954 control->values = devm_kcalloc(dev, hweight64(control->cn_list), 955 sizeof(int), GFP_KERNEL); 956 if (!control->values) 957 return -ENOMEM; 958 959 switch (control->mode) { 960 case SDCA_ACCESS_MODE_DC: 961 ret = find_sdca_control_value(dev, entity, control_node, control, 962 "dc-value"); 963 if (ret) { 964 dev_err(dev, "%s: control %#x: dc value missing: %d\n", 965 entity->label, control->sel, ret); 966 return ret; 967 } 968 969 control->has_fixed = true; 970 break; 971 case SDCA_ACCESS_MODE_RW: 972 case SDCA_ACCESS_MODE_DUAL: 973 ret = find_sdca_control_value(dev, entity, control_node, control, 974 "default-value"); 975 if (!ret) 976 control->has_default = true; 977 978 ret = find_sdca_control_value(dev, entity, control_node, control, 979 "fixed-value"); 980 if (!ret) 981 control->has_fixed = true; 982 fallthrough; 983 case SDCA_ACCESS_MODE_RO: 984 control->deferrable = fwnode_property_read_bool(control_node, 985 "mipi-sdca-control-deferrable"); 986 break; 987 default: 988 break; 989 } 990 991 control->is_volatile = find_sdca_control_volatile(entity, control); 992 993 ret = find_sdca_control_range(dev, control_node, &control->range); 994 if (ret) { 995 dev_err(dev, "%s: control %#x: range missing: %d\n", 996 entity->label, control->sel, ret); 997 return ret; 998 } 999 1000 ret = fwnode_property_read_u32(control_node, 1001 "mipi-sdca-control-interrupt-position", 1002 &tmp); 1003 if (!ret) 1004 control->interrupt_position = tmp; 1005 else 1006 control->interrupt_position = SDCA_NO_INTERRUPT; 1007 1008 control->label = find_sdca_control_label(dev, entity, control); 1009 if (!control->label) 1010 return -ENOMEM; 1011 1012 control->type = find_sdca_control_datatype(entity, control); 1013 control->nbits = find_sdca_control_bits(entity, control); 1014 1015 dev_dbg(dev, "%s: %s: control %#x mode %#x layers %#x cn %#llx int %d %s\n", 1016 entity->label, control->label, control->sel, 1017 control->mode, control->layers, control->cn_list, 1018 control->interrupt_position, control->deferrable ? "deferrable" : ""); 1019 1020 return 0; 1021 } 1022 1023 static int find_sdca_entity_controls(struct device *dev, 1024 struct fwnode_handle *entity_node, 1025 struct sdca_entity *entity) 1026 { 1027 struct sdca_control *controls; 1028 int num_controls; 1029 u64 control_list; 1030 int control_sel; 1031 int i, ret; 1032 1033 ret = fwnode_property_read_u64(entity_node, "mipi-sdca-control-list", &control_list); 1034 if (ret == -EINVAL) { 1035 /* Allow missing control lists, assume no controls. */ 1036 dev_warn(dev, "%s: missing control list\n", entity->label); 1037 return 0; 1038 } else if (ret) { 1039 dev_err(dev, "%s: failed to read control list: %d\n", entity->label, ret); 1040 return ret; 1041 } else if (!control_list) { 1042 return 0; 1043 } 1044 1045 num_controls = hweight64(control_list); 1046 controls = devm_kcalloc(dev, num_controls, sizeof(*controls), GFP_KERNEL); 1047 if (!controls) 1048 return -ENOMEM; 1049 1050 i = 0; 1051 for_each_set_bit(control_sel, (unsigned long *)&control_list, 1052 BITS_PER_TYPE(control_list)) { 1053 struct fwnode_handle *control_node; 1054 char control_property[SDCA_PROPERTY_LENGTH]; 1055 1056 /* DisCo uses upper-case for hex numbers */ 1057 snprintf(control_property, sizeof(control_property), 1058 "mipi-sdca-control-0x%X-subproperties", control_sel); 1059 1060 control_node = fwnode_get_named_child_node(entity_node, control_property); 1061 if (!control_node) { 1062 dev_err(dev, "%s: control node %s not found\n", 1063 entity->label, control_property); 1064 return -EINVAL; 1065 } 1066 1067 controls[i].sel = control_sel; 1068 1069 ret = find_sdca_entity_control(dev, entity, control_node, &controls[i]); 1070 fwnode_handle_put(control_node); 1071 if (ret) 1072 return ret; 1073 1074 i++; 1075 } 1076 1077 entity->num_controls = num_controls; 1078 entity->controls = controls; 1079 1080 return 0; 1081 } 1082 1083 static bool find_sdca_iot_dataport(struct sdca_entity_iot *terminal) 1084 { 1085 switch (terminal->type) { 1086 case SDCA_TERM_TYPE_GENERIC: 1087 case SDCA_TERM_TYPE_ULTRASOUND: 1088 case SDCA_TERM_TYPE_CAPTURE_DIRECT_PCM_MIC: 1089 case SDCA_TERM_TYPE_RAW_PDM_MIC: 1090 case SDCA_TERM_TYPE_SPEECH: 1091 case SDCA_TERM_TYPE_VOICE: 1092 case SDCA_TERM_TYPE_SECONDARY_PCM_MIC: 1093 case SDCA_TERM_TYPE_ACOUSTIC_CONTEXT_AWARENESS: 1094 case SDCA_TERM_TYPE_DTOD_STREAM: 1095 case SDCA_TERM_TYPE_REFERENCE_STREAM: 1096 case SDCA_TERM_TYPE_SENSE_CAPTURE: 1097 case SDCA_TERM_TYPE_STREAMING_MIC: 1098 case SDCA_TERM_TYPE_OPTIMIZATION_STREAM: 1099 case SDCA_TERM_TYPE_PDM_RENDER_STREAM: 1100 case SDCA_TERM_TYPE_COMPANION_DATA: 1101 return true; 1102 default: 1103 return false; 1104 } 1105 } 1106 1107 static int find_sdca_entity_iot(struct device *dev, 1108 struct fwnode_handle *entity_node, 1109 struct sdca_entity *entity) 1110 { 1111 struct sdca_entity_iot *terminal = &entity->iot; 1112 u32 tmp; 1113 int ret; 1114 1115 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-terminal-type", &tmp); 1116 if (ret) { 1117 dev_err(dev, "%s: terminal type missing: %d\n", entity->label, ret); 1118 return ret; 1119 } 1120 1121 terminal->type = tmp; 1122 terminal->is_dataport = find_sdca_iot_dataport(terminal); 1123 1124 if (!terminal->is_dataport) { 1125 const char *type_name = sdca_find_terminal_name(terminal->type); 1126 1127 if (type_name) 1128 entity->label = devm_kasprintf(dev, GFP_KERNEL, "%s %s", 1129 entity->label, type_name); 1130 } 1131 1132 ret = fwnode_property_read_u32(entity_node, 1133 "mipi-sdca-terminal-reference-number", &tmp); 1134 if (!ret) 1135 terminal->reference = tmp; 1136 1137 ret = fwnode_property_read_u32(entity_node, 1138 "mipi-sdca-terminal-connector-type", &tmp); 1139 if (!ret) 1140 terminal->connector = tmp; 1141 1142 ret = fwnode_property_read_u32(entity_node, 1143 "mipi-sdca-terminal-transducer-count", &tmp); 1144 if (!ret) 1145 terminal->num_transducer = tmp; 1146 1147 dev_dbg(dev, "%s: terminal type %#x ref %#x conn %#x count %d\n", 1148 entity->label, terminal->type, terminal->reference, 1149 terminal->connector, terminal->num_transducer); 1150 1151 return 0; 1152 } 1153 1154 static int find_sdca_entity_cs(struct device *dev, 1155 struct fwnode_handle *entity_node, 1156 struct sdca_entity *entity) 1157 { 1158 struct sdca_entity_cs *clock = &entity->cs; 1159 u32 tmp; 1160 int ret; 1161 1162 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-cs-type", &tmp); 1163 if (ret) { 1164 dev_err(dev, "%s: clock type missing: %d\n", entity->label, ret); 1165 return ret; 1166 } 1167 1168 clock->type = tmp; 1169 1170 ret = fwnode_property_read_u32(entity_node, 1171 "mipi-sdca-clock-valid-max-delay", &tmp); 1172 if (!ret) 1173 clock->max_delay = tmp; 1174 1175 dev_dbg(dev, "%s: clock type %#x delay %d\n", entity->label, 1176 clock->type, clock->max_delay); 1177 1178 return 0; 1179 } 1180 1181 static int find_sdca_entity_pde(struct device *dev, 1182 struct fwnode_handle *entity_node, 1183 struct sdca_entity *entity) 1184 { 1185 static const int mult_delay = 3; 1186 struct sdca_entity_pde *power = &entity->pde; 1187 u32 *delay_list __free(kfree) = NULL; 1188 struct sdca_pde_delay *delays; 1189 int num_delays; 1190 int i, j; 1191 1192 num_delays = fwnode_property_count_u32(entity_node, 1193 "mipi-sdca-powerdomain-transition-max-delay"); 1194 if (num_delays <= 0) { 1195 dev_err(dev, "%s: max delay list missing: %d\n", 1196 entity->label, num_delays); 1197 return -EINVAL; 1198 } else if (num_delays % mult_delay != 0) { 1199 dev_err(dev, "%s: delays not multiple of %d\n", 1200 entity->label, mult_delay); 1201 return -EINVAL; 1202 } else if (num_delays > SDCA_MAX_DELAY_COUNT) { 1203 dev_err(dev, "%s: maximum number of transition delays exceeded\n", 1204 entity->label); 1205 return -EINVAL; 1206 } 1207 1208 delay_list = kcalloc(num_delays, sizeof(*delay_list), GFP_KERNEL); 1209 if (!delay_list) 1210 return -ENOMEM; 1211 1212 fwnode_property_read_u32_array(entity_node, 1213 "mipi-sdca-powerdomain-transition-max-delay", 1214 delay_list, num_delays); 1215 1216 num_delays /= mult_delay; 1217 1218 delays = devm_kcalloc(dev, num_delays, sizeof(*delays), GFP_KERNEL); 1219 if (!delays) 1220 return -ENOMEM; 1221 1222 for (i = 0, j = 0; i < num_delays; i++) { 1223 delays[i].from_ps = delay_list[j++]; 1224 delays[i].to_ps = delay_list[j++]; 1225 delays[i].us = delay_list[j++]; 1226 1227 dev_dbg(dev, "%s: from %#x to %#x delay %dus\n", entity->label, 1228 delays[i].from_ps, delays[i].to_ps, delays[i].us); 1229 } 1230 1231 power->num_max_delay = num_delays; 1232 power->max_delay = delays; 1233 1234 return 0; 1235 } 1236 1237 struct raw_ge_mode { 1238 u8 val; 1239 u8 num_controls; 1240 struct { 1241 u8 id; 1242 u8 sel; 1243 u8 cn; 1244 __le32 val; 1245 } __packed controls[] __counted_by(num_controls); 1246 } __packed; 1247 1248 static int find_sdca_entity_ge(struct device *dev, 1249 struct fwnode_handle *entity_node, 1250 struct sdca_entity *entity) 1251 { 1252 struct sdca_entity_ge *group = &entity->ge; 1253 u8 *affected_list __free(kfree) = NULL; 1254 u8 *affected_iter; 1255 int num_affected; 1256 int i, j; 1257 1258 num_affected = fwnode_property_count_u8(entity_node, 1259 "mipi-sdca-ge-selectedmode-controls-affected"); 1260 if (!num_affected) { 1261 return 0; 1262 } else if (num_affected < 0) { 1263 dev_err(dev, "%s: failed to read affected controls: %d\n", 1264 entity->label, num_affected); 1265 return num_affected; 1266 } else if (num_affected > SDCA_MAX_AFFECTED_COUNT) { 1267 dev_err(dev, "%s: maximum affected controls size exceeded\n", 1268 entity->label); 1269 return -EINVAL; 1270 } 1271 1272 affected_list = kcalloc(num_affected, sizeof(*affected_list), GFP_KERNEL); 1273 if (!affected_list) 1274 return -ENOMEM; 1275 1276 fwnode_property_read_u8_array(entity_node, 1277 "mipi-sdca-ge-selectedmode-controls-affected", 1278 affected_list, num_affected); 1279 1280 group->num_modes = *affected_list; 1281 affected_iter = affected_list + 1; 1282 1283 group->modes = devm_kcalloc(dev, group->num_modes, sizeof(*group->modes), 1284 GFP_KERNEL); 1285 if (!group->modes) 1286 return -ENOMEM; 1287 1288 for (i = 0; i < group->num_modes; i++) { 1289 struct raw_ge_mode *raw = (struct raw_ge_mode *)affected_iter; 1290 struct sdca_ge_mode *mode = &group->modes[i]; 1291 1292 affected_iter += sizeof(*raw); 1293 if (affected_iter > affected_list + num_affected) 1294 goto bad_list; 1295 1296 mode->val = raw->val; 1297 mode->num_controls = raw->num_controls; 1298 1299 affected_iter += mode->num_controls * sizeof(raw->controls[0]); 1300 if (affected_iter > affected_list + num_affected) 1301 goto bad_list; 1302 1303 mode->controls = devm_kcalloc(dev, mode->num_controls, 1304 sizeof(*mode->controls), GFP_KERNEL); 1305 if (!mode->controls) 1306 return -ENOMEM; 1307 1308 for (j = 0; j < mode->num_controls; j++) { 1309 mode->controls[j].id = raw->controls[j].id; 1310 mode->controls[j].sel = raw->controls[j].sel; 1311 mode->controls[j].cn = raw->controls[j].cn; 1312 mode->controls[j].val = le32_to_cpu(raw->controls[j].val); 1313 } 1314 } 1315 1316 return 0; 1317 1318 bad_list: 1319 dev_err(dev, "%s: malformed affected controls list\n", entity->label); 1320 return -EINVAL; 1321 } 1322 1323 static int 1324 find_sdca_entity_hide(struct device *dev, struct sdw_slave *sdw, 1325 struct fwnode_handle *function_node, 1326 struct fwnode_handle *entity_node, struct sdca_entity *entity) 1327 { 1328 struct sdca_entity_hide *hide = &entity->hide; 1329 unsigned int delay, *af_list = hide->af_number_list; 1330 int nval, ret; 1331 unsigned char *report_desc = NULL; 1332 1333 ret = fwnode_property_read_u32(entity_node, 1334 "mipi-sdca-RxUMP-ownership-transition-max-delay", &delay); 1335 if (!ret) 1336 hide->max_delay = delay; 1337 1338 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDTx-supported-report-ids"); 1339 if (nval > 0) { 1340 hide->num_hidtx_ids = nval; 1341 hide->hidtx_ids = devm_kcalloc(dev, hide->num_hidtx_ids, 1342 sizeof(*hide->hidtx_ids), GFP_KERNEL); 1343 if (!hide->hidtx_ids) 1344 return -ENOMEM; 1345 1346 ret = fwnode_property_read_u32_array(entity_node, 1347 "mipi-sdca-HIDTx-supported-report-ids", 1348 hide->hidtx_ids, 1349 hide->num_hidtx_ids); 1350 if (ret < 0) 1351 return ret; 1352 } 1353 1354 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDRx-supported-report-ids"); 1355 if (nval > 0) { 1356 hide->num_hidrx_ids = nval; 1357 hide->hidrx_ids = devm_kcalloc(dev, hide->num_hidrx_ids, 1358 sizeof(*hide->hidrx_ids), GFP_KERNEL); 1359 if (!hide->hidrx_ids) 1360 return -ENOMEM; 1361 1362 ret = fwnode_property_read_u32_array(entity_node, 1363 "mipi-sdca-HIDRx-supported-report-ids", 1364 hide->hidrx_ids, 1365 hide->num_hidrx_ids); 1366 if (ret < 0) 1367 return ret; 1368 } 1369 1370 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-hide-related-audio-function-list"); 1371 if (nval <= 0) { 1372 dev_err(dev, "%pfwP: audio function numbers list missing: %d\n", 1373 entity_node, nval); 1374 return -EINVAL; 1375 } else if (nval > SDCA_MAX_FUNCTION_COUNT) { 1376 dev_err(dev, "%pfwP: maximum number of audio function exceeded\n", entity_node); 1377 return -EINVAL; 1378 } 1379 1380 hide->hide_reside_function_num = nval; 1381 fwnode_property_read_u32_array(entity_node, 1382 "mipi-sdca-hide-related-audio-function-list", af_list, nval); 1383 1384 nval = fwnode_property_count_u8(function_node, "mipi-sdca-hid-descriptor"); 1385 if (nval) 1386 fwnode_property_read_u8_array(function_node, "mipi-sdca-hid-descriptor", 1387 (u8 *)&hide->hid_desc, nval); 1388 1389 if (hide->hid_desc.bNumDescriptors) { 1390 nval = fwnode_property_count_u8(function_node, "mipi-sdca-report-descriptor"); 1391 if (nval) { 1392 report_desc = devm_kzalloc(dev, nval, GFP_KERNEL); 1393 if (!report_desc) 1394 return -ENOMEM; 1395 hide->hid_report_desc = report_desc; 1396 fwnode_property_read_u8_array(function_node, "mipi-sdca-report-descriptor", 1397 report_desc, nval); 1398 1399 /* add HID device */ 1400 ret = sdca_add_hid_device(dev, sdw, entity); 1401 if (ret) { 1402 dev_err(dev, "%pfwP: failed to add HID device: %d\n", entity_node, ret); 1403 return ret; 1404 } 1405 } 1406 } 1407 1408 return 0; 1409 } 1410 1411 static int find_sdca_entity_xu(struct device *dev, 1412 struct fwnode_handle *entity_node, 1413 struct sdca_entity *entity) 1414 { 1415 struct sdca_entity_xu *xu = &entity->xu; 1416 u32 tmp; 1417 int ret; 1418 1419 ret = fwnode_property_read_u32(entity_node, 1420 "mipi-sdca-RxUMP-ownership-transition-max-delay", 1421 &tmp); 1422 if (!ret) 1423 xu->max_delay = tmp; 1424 1425 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-FDL-reset-mechanism", 1426 &tmp); 1427 if (!ret) 1428 xu->reset_mechanism = tmp; 1429 1430 return 0; 1431 } 1432 1433 static int find_sdca_entity(struct device *dev, struct sdw_slave *sdw, 1434 struct fwnode_handle *function_node, 1435 struct fwnode_handle *entity_node, 1436 struct sdca_entity *entity) 1437 { 1438 u32 tmp; 1439 int ret; 1440 1441 ret = fwnode_property_read_string(entity_node, "mipi-sdca-entity-label", 1442 &entity->label); 1443 if (ret) { 1444 dev_err(dev, "%pfwP: entity %#x: label missing: %d\n", 1445 function_node, entity->id, ret); 1446 return ret; 1447 } 1448 1449 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-entity-type", &tmp); 1450 if (ret) { 1451 dev_err(dev, "%s: type missing: %d\n", entity->label, ret); 1452 return ret; 1453 } 1454 1455 entity->type = tmp; 1456 1457 dev_dbg(dev, "%s: entity %#x type %#x\n", 1458 entity->label, entity->id, entity->type); 1459 1460 switch (entity->type) { 1461 case SDCA_ENTITY_TYPE_IT: 1462 case SDCA_ENTITY_TYPE_OT: 1463 ret = find_sdca_entity_iot(dev, entity_node, entity); 1464 break; 1465 case SDCA_ENTITY_TYPE_XU: 1466 ret = find_sdca_entity_xu(dev, entity_node, entity); 1467 break; 1468 case SDCA_ENTITY_TYPE_CS: 1469 ret = find_sdca_entity_cs(dev, entity_node, entity); 1470 break; 1471 case SDCA_ENTITY_TYPE_PDE: 1472 ret = find_sdca_entity_pde(dev, entity_node, entity); 1473 break; 1474 case SDCA_ENTITY_TYPE_GE: 1475 ret = find_sdca_entity_ge(dev, entity_node, entity); 1476 break; 1477 case SDCA_ENTITY_TYPE_HIDE: 1478 ret = find_sdca_entity_hide(dev, sdw, function_node, 1479 entity_node, entity); 1480 break; 1481 default: 1482 break; 1483 } 1484 if (ret) 1485 return ret; 1486 1487 ret = find_sdca_entity_controls(dev, entity_node, entity); 1488 if (ret) 1489 return ret; 1490 1491 return 0; 1492 } 1493 1494 static int find_sdca_entities(struct device *dev, struct sdw_slave *sdw, 1495 struct fwnode_handle *function_node, 1496 struct sdca_function_data *function) 1497 { 1498 u32 *entity_list __free(kfree) = NULL; 1499 struct sdca_entity *entities; 1500 int num_entities; 1501 int i, ret; 1502 1503 num_entities = fwnode_property_count_u32(function_node, 1504 "mipi-sdca-entity-id-list"); 1505 if (num_entities <= 0) { 1506 dev_err(dev, "%pfwP: entity id list missing: %d\n", 1507 function_node, num_entities); 1508 return -EINVAL; 1509 } else if (num_entities > SDCA_MAX_ENTITY_COUNT) { 1510 dev_err(dev, "%pfwP: maximum number of entities exceeded\n", 1511 function_node); 1512 return -EINVAL; 1513 } 1514 1515 /* Add 1 to make space for Entity 0 */ 1516 entities = devm_kcalloc(dev, num_entities + 1, sizeof(*entities), GFP_KERNEL); 1517 if (!entities) 1518 return -ENOMEM; 1519 1520 entity_list = kcalloc(num_entities, sizeof(*entity_list), GFP_KERNEL); 1521 if (!entity_list) 1522 return -ENOMEM; 1523 1524 fwnode_property_read_u32_array(function_node, "mipi-sdca-entity-id-list", 1525 entity_list, num_entities); 1526 1527 for (i = 0; i < num_entities; i++) 1528 entities[i].id = entity_list[i]; 1529 1530 /* now read subproperties */ 1531 for (i = 0; i < num_entities; i++) { 1532 char entity_property[SDCA_PROPERTY_LENGTH]; 1533 struct fwnode_handle *entity_node; 1534 1535 /* DisCo uses upper-case for hex numbers */ 1536 snprintf(entity_property, sizeof(entity_property), 1537 "mipi-sdca-entity-id-0x%X-subproperties", entities[i].id); 1538 1539 entity_node = fwnode_get_named_child_node(function_node, entity_property); 1540 if (!entity_node) { 1541 dev_err(dev, "%pfwP: entity node %s not found\n", 1542 function_node, entity_property); 1543 return -EINVAL; 1544 } 1545 1546 ret = find_sdca_entity(dev, sdw, function_node, 1547 entity_node, &entities[i]); 1548 fwnode_handle_put(entity_node); 1549 if (ret) 1550 return ret; 1551 } 1552 1553 /* 1554 * Add Entity 0 at end of the array, makes it easy to skip during 1555 * all the Entity searches involved in creating connections. 1556 */ 1557 entities[num_entities].label = "entity0"; 1558 1559 ret = find_sdca_entity_controls(dev, function_node, &entities[num_entities]); 1560 if (ret) 1561 return ret; 1562 1563 function->num_entities = num_entities + 1; 1564 function->entities = entities; 1565 1566 return 0; 1567 } 1568 1569 static struct sdca_entity *find_sdca_entity_by_label(struct sdca_function_data *function, 1570 const char *entity_label) 1571 { 1572 int i; 1573 1574 for (i = 0; i < function->num_entities; i++) { 1575 struct sdca_entity *entity = &function->entities[i]; 1576 1577 if (!strncmp(entity->label, entity_label, strlen(entity_label))) 1578 return entity; 1579 } 1580 1581 return NULL; 1582 } 1583 1584 static struct sdca_entity *find_sdca_entity_by_id(struct sdca_function_data *function, 1585 const int id) 1586 { 1587 int i; 1588 1589 for (i = 0; i < function->num_entities; i++) { 1590 struct sdca_entity *entity = &function->entities[i]; 1591 1592 if (entity->id == id) 1593 return entity; 1594 } 1595 1596 return NULL; 1597 } 1598 1599 static int find_sdca_entity_connection_iot(struct device *dev, 1600 struct sdca_function_data *function, 1601 struct fwnode_handle *entity_node, 1602 struct sdca_entity *entity) 1603 { 1604 struct sdca_entity_iot *terminal = &entity->iot; 1605 struct fwnode_handle *clock_node; 1606 struct sdca_entity *clock_entity; 1607 const char *clock_label; 1608 int ret; 1609 1610 clock_node = fwnode_get_named_child_node(entity_node, 1611 "mipi-sdca-terminal-clock-connection"); 1612 if (!clock_node) 1613 return 0; 1614 1615 ret = fwnode_property_read_string(clock_node, "mipi-sdca-entity-label", 1616 &clock_label); 1617 if (ret) { 1618 dev_err(dev, "%s: clock label missing: %d\n", entity->label, ret); 1619 fwnode_handle_put(clock_node); 1620 return ret; 1621 } 1622 1623 clock_entity = find_sdca_entity_by_label(function, clock_label); 1624 if (!clock_entity) { 1625 dev_err(dev, "%s: failed to find clock with label %s\n", 1626 entity->label, clock_label); 1627 fwnode_handle_put(clock_node); 1628 return -EINVAL; 1629 } 1630 1631 terminal->clock = clock_entity; 1632 1633 dev_dbg(dev, "%s -> %s\n", clock_entity->label, entity->label); 1634 1635 fwnode_handle_put(clock_node); 1636 return 0; 1637 } 1638 1639 static int find_sdca_entity_connection_pde(struct device *dev, 1640 struct sdca_function_data *function, 1641 struct fwnode_handle *entity_node, 1642 struct sdca_entity *entity) 1643 { 1644 struct sdca_entity_pde *power = &entity->pde; 1645 u32 *managed_list __free(kfree) = NULL; 1646 struct sdca_entity **managed; 1647 int num_managed; 1648 int i; 1649 1650 num_managed = fwnode_property_count_u32(entity_node, 1651 "mipi-sdca-powerdomain-managed-list"); 1652 if (!num_managed) { 1653 return 0; 1654 } else if (num_managed < 0) { 1655 dev_err(dev, "%s: managed list missing: %d\n", entity->label, num_managed); 1656 return num_managed; 1657 } else if (num_managed > SDCA_MAX_ENTITY_COUNT) { 1658 dev_err(dev, "%s: maximum number of managed entities exceeded\n", 1659 entity->label); 1660 return -EINVAL; 1661 } 1662 1663 managed = devm_kcalloc(dev, num_managed, sizeof(*managed), GFP_KERNEL); 1664 if (!managed) 1665 return -ENOMEM; 1666 1667 managed_list = kcalloc(num_managed, sizeof(*managed_list), GFP_KERNEL); 1668 if (!managed_list) 1669 return -ENOMEM; 1670 1671 fwnode_property_read_u32_array(entity_node, 1672 "mipi-sdca-powerdomain-managed-list", 1673 managed_list, num_managed); 1674 1675 for (i = 0; i < num_managed; i++) { 1676 managed[i] = find_sdca_entity_by_id(function, managed_list[i]); 1677 if (!managed[i]) { 1678 dev_err(dev, "%s: failed to find entity with id %#x\n", 1679 entity->label, managed_list[i]); 1680 return -EINVAL; 1681 } 1682 1683 dev_dbg(dev, "%s -> %s\n", managed[i]->label, entity->label); 1684 } 1685 1686 power->num_managed = num_managed; 1687 power->managed = managed; 1688 1689 return 0; 1690 } 1691 1692 static int find_sdca_entity_connection_ge(struct device *dev, 1693 struct sdca_function_data *function, 1694 struct fwnode_handle *entity_node, 1695 struct sdca_entity *entity) 1696 { 1697 int i, j; 1698 1699 for (i = 0; i < entity->ge.num_modes; i++) { 1700 struct sdca_ge_mode *mode = &entity->ge.modes[i]; 1701 1702 for (j = 0; j < mode->num_controls; j++) { 1703 struct sdca_ge_control *affected = &mode->controls[j]; 1704 struct sdca_entity *managed; 1705 1706 managed = find_sdca_entity_by_id(function, affected->id); 1707 if (!managed) { 1708 dev_err(dev, "%s: failed to find entity with id %#x\n", 1709 entity->label, affected->id); 1710 return -EINVAL; 1711 } 1712 1713 if (managed->group && managed->group != entity) { 1714 dev_err(dev, 1715 "%s: entity controlled by two groups %s, %s\n", 1716 managed->label, managed->group->label, 1717 entity->label); 1718 return -EINVAL; 1719 } 1720 1721 managed->group = entity; 1722 } 1723 } 1724 1725 return 0; 1726 } 1727 1728 static int find_sdca_entity_connection(struct device *dev, 1729 struct sdca_function_data *function, 1730 struct fwnode_handle *entity_node, 1731 struct sdca_entity *entity) 1732 { 1733 struct sdca_entity **pins; 1734 int num_pins, pin; 1735 u64 pin_list; 1736 int i, ret; 1737 1738 switch (entity->type) { 1739 case SDCA_ENTITY_TYPE_IT: 1740 case SDCA_ENTITY_TYPE_OT: 1741 ret = find_sdca_entity_connection_iot(dev, function, 1742 entity_node, entity); 1743 break; 1744 case SDCA_ENTITY_TYPE_PDE: 1745 ret = find_sdca_entity_connection_pde(dev, function, 1746 entity_node, entity); 1747 break; 1748 case SDCA_ENTITY_TYPE_GE: 1749 ret = find_sdca_entity_connection_ge(dev, function, 1750 entity_node, entity); 1751 break; 1752 default: 1753 ret = 0; 1754 break; 1755 } 1756 if (ret) 1757 return ret; 1758 1759 ret = fwnode_property_read_u64(entity_node, "mipi-sdca-input-pin-list", &pin_list); 1760 if (ret == -EINVAL) { 1761 /* Allow missing pin lists, assume no pins. */ 1762 return 0; 1763 } else if (ret) { 1764 dev_err(dev, "%s: failed to read pin list: %d\n", entity->label, ret); 1765 return ret; 1766 } else if (pin_list & BIT(0)) { 1767 /* 1768 * Each bit set in the pin-list refers to an entity_id in this 1769 * Function. Entity 0 is an illegal connection since it is used 1770 * for Function-level configurations. 1771 */ 1772 dev_err(dev, "%s: pin 0 used as input\n", entity->label); 1773 return -EINVAL; 1774 } else if (!pin_list) { 1775 return 0; 1776 } 1777 1778 num_pins = hweight64(pin_list); 1779 pins = devm_kcalloc(dev, num_pins, sizeof(*pins), GFP_KERNEL); 1780 if (!pins) 1781 return -ENOMEM; 1782 1783 i = 0; 1784 for_each_set_bit(pin, (unsigned long *)&pin_list, BITS_PER_TYPE(pin_list)) { 1785 char pin_property[SDCA_PROPERTY_LENGTH]; 1786 struct fwnode_handle *connected_node; 1787 struct sdca_entity *connected_entity; 1788 const char *connected_label; 1789 1790 snprintf(pin_property, sizeof(pin_property), "mipi-sdca-input-pin-%d", pin); 1791 1792 connected_node = fwnode_get_named_child_node(entity_node, pin_property); 1793 if (!connected_node) { 1794 dev_err(dev, "%s: pin node %s not found\n", 1795 entity->label, pin_property); 1796 return -EINVAL; 1797 } 1798 1799 ret = fwnode_property_read_string(connected_node, "mipi-sdca-entity-label", 1800 &connected_label); 1801 if (ret) { 1802 dev_err(dev, "%s: pin %d label missing: %d\n", 1803 entity->label, pin, ret); 1804 fwnode_handle_put(connected_node); 1805 return ret; 1806 } 1807 1808 connected_entity = find_sdca_entity_by_label(function, connected_label); 1809 if (!connected_entity) { 1810 dev_err(dev, "%s: failed to find entity with label %s\n", 1811 entity->label, connected_label); 1812 fwnode_handle_put(connected_node); 1813 return -EINVAL; 1814 } 1815 1816 pins[i] = connected_entity; 1817 1818 dev_dbg(dev, "%s -> %s\n", connected_entity->label, entity->label); 1819 1820 i++; 1821 fwnode_handle_put(connected_node); 1822 } 1823 1824 entity->num_sources = num_pins; 1825 entity->sources = pins; 1826 1827 return 0; 1828 } 1829 1830 static int find_sdca_connections(struct device *dev, 1831 struct fwnode_handle *function_node, 1832 struct sdca_function_data *function) 1833 { 1834 int i; 1835 1836 /* Entity 0 cannot have connections */ 1837 for (i = 0; i < function->num_entities - 1; i++) { 1838 struct sdca_entity *entity = &function->entities[i]; 1839 char entity_property[SDCA_PROPERTY_LENGTH]; 1840 struct fwnode_handle *entity_node; 1841 int ret; 1842 1843 /* DisCo uses upper-case for hex numbers */ 1844 snprintf(entity_property, sizeof(entity_property), 1845 "mipi-sdca-entity-id-0x%X-subproperties", 1846 entity->id); 1847 1848 entity_node = fwnode_get_named_child_node(function_node, entity_property); 1849 if (!entity_node) { 1850 dev_err(dev, "%pfwP: entity node %s not found\n", 1851 function_node, entity_property); 1852 return -EINVAL; 1853 } 1854 1855 ret = find_sdca_entity_connection(dev, function, entity_node, entity); 1856 fwnode_handle_put(entity_node); 1857 if (ret) 1858 return ret; 1859 } 1860 1861 return 0; 1862 } 1863 1864 static int find_sdca_cluster_channel(struct device *dev, 1865 struct sdca_cluster *cluster, 1866 struct fwnode_handle *channel_node, 1867 struct sdca_channel *channel) 1868 { 1869 u32 tmp; 1870 int ret; 1871 1872 ret = fwnode_property_read_u32(channel_node, "mipi-sdca-cluster-channel-id", &tmp); 1873 if (ret) { 1874 dev_err(dev, "cluster %#x: missing channel id: %d\n", 1875 cluster->id, ret); 1876 return ret; 1877 } 1878 1879 channel->id = tmp; 1880 1881 ret = fwnode_property_read_u32(channel_node, 1882 "mipi-sdca-cluster-channel-purpose", 1883 &tmp); 1884 if (ret) { 1885 dev_err(dev, "cluster %#x: channel %#x: missing purpose: %d\n", 1886 cluster->id, channel->id, ret); 1887 return ret; 1888 } 1889 1890 channel->purpose = tmp; 1891 1892 ret = fwnode_property_read_u32(channel_node, 1893 "mipi-sdca-cluster-channel-relationship", 1894 &tmp); 1895 if (ret) { 1896 dev_err(dev, "cluster %#x: channel %#x: missing relationship: %d\n", 1897 cluster->id, channel->id, ret); 1898 return ret; 1899 } 1900 1901 channel->relationship = tmp; 1902 1903 dev_dbg(dev, "cluster %#x: channel id %#x purpose %#x relationship %#x\n", 1904 cluster->id, channel->id, channel->purpose, channel->relationship); 1905 1906 return 0; 1907 } 1908 1909 static int find_sdca_cluster_channels(struct device *dev, 1910 struct fwnode_handle *cluster_node, 1911 struct sdca_cluster *cluster) 1912 { 1913 struct sdca_channel *channels; 1914 u32 num_channels; 1915 int i, ret; 1916 1917 ret = fwnode_property_read_u32(cluster_node, "mipi-sdca-channel-count", 1918 &num_channels); 1919 if (ret < 0) { 1920 dev_err(dev, "cluster %#x: failed to read channel list: %d\n", 1921 cluster->id, ret); 1922 return ret; 1923 } else if (num_channels > SDCA_MAX_CHANNEL_COUNT) { 1924 dev_err(dev, "cluster %#x: maximum number of channels exceeded\n", 1925 cluster->id); 1926 return -EINVAL; 1927 } 1928 1929 channels = devm_kcalloc(dev, num_channels, sizeof(*channels), GFP_KERNEL); 1930 if (!channels) 1931 return -ENOMEM; 1932 1933 for (i = 0; i < num_channels; i++) { 1934 char channel_property[SDCA_PROPERTY_LENGTH]; 1935 struct fwnode_handle *channel_node; 1936 1937 /* DisCo uses upper-case for hex numbers */ 1938 snprintf(channel_property, sizeof(channel_property), 1939 "mipi-sdca-channel-%d-subproperties", i + 1); 1940 1941 channel_node = fwnode_get_named_child_node(cluster_node, channel_property); 1942 if (!channel_node) { 1943 dev_err(dev, "cluster %#x: channel node %s not found\n", 1944 cluster->id, channel_property); 1945 return -EINVAL; 1946 } 1947 1948 ret = find_sdca_cluster_channel(dev, cluster, channel_node, &channels[i]); 1949 fwnode_handle_put(channel_node); 1950 if (ret) 1951 return ret; 1952 } 1953 1954 cluster->num_channels = num_channels; 1955 cluster->channels = channels; 1956 1957 return 0; 1958 } 1959 1960 static int find_sdca_clusters(struct device *dev, 1961 struct fwnode_handle *function_node, 1962 struct sdca_function_data *function) 1963 { 1964 u32 *cluster_list __free(kfree) = NULL; 1965 struct sdca_cluster *clusters; 1966 int num_clusters; 1967 int i, ret; 1968 1969 num_clusters = fwnode_property_count_u32(function_node, "mipi-sdca-cluster-id-list"); 1970 if (!num_clusters || num_clusters == -EINVAL) { 1971 return 0; 1972 } else if (num_clusters < 0) { 1973 dev_err(dev, "%pfwP: failed to read cluster id list: %d\n", 1974 function_node, num_clusters); 1975 return num_clusters; 1976 } else if (num_clusters > SDCA_MAX_CLUSTER_COUNT) { 1977 dev_err(dev, "%pfwP: maximum number of clusters exceeded\n", function_node); 1978 return -EINVAL; 1979 } 1980 1981 clusters = devm_kcalloc(dev, num_clusters, sizeof(*clusters), GFP_KERNEL); 1982 if (!clusters) 1983 return -ENOMEM; 1984 1985 cluster_list = kcalloc(num_clusters, sizeof(*cluster_list), GFP_KERNEL); 1986 if (!cluster_list) 1987 return -ENOMEM; 1988 1989 fwnode_property_read_u32_array(function_node, "mipi-sdca-cluster-id-list", 1990 cluster_list, num_clusters); 1991 1992 for (i = 0; i < num_clusters; i++) 1993 clusters[i].id = cluster_list[i]; 1994 1995 /* now read subproperties */ 1996 for (i = 0; i < num_clusters; i++) { 1997 char cluster_property[SDCA_PROPERTY_LENGTH]; 1998 struct fwnode_handle *cluster_node; 1999 2000 /* DisCo uses upper-case for hex numbers */ 2001 snprintf(cluster_property, sizeof(cluster_property), 2002 "mipi-sdca-cluster-id-0x%X-subproperties", clusters[i].id); 2003 2004 cluster_node = fwnode_get_named_child_node(function_node, cluster_property); 2005 if (!cluster_node) { 2006 dev_err(dev, "%pfwP: cluster node %s not found\n", 2007 function_node, cluster_property); 2008 return -EINVAL; 2009 } 2010 2011 ret = find_sdca_cluster_channels(dev, cluster_node, &clusters[i]); 2012 fwnode_handle_put(cluster_node); 2013 if (ret) 2014 return ret; 2015 } 2016 2017 function->num_clusters = num_clusters; 2018 function->clusters = clusters; 2019 2020 return 0; 2021 } 2022 2023 static int find_sdca_filesets(struct device *dev, struct sdw_slave *sdw, 2024 struct fwnode_handle *function_node, 2025 struct sdca_function_data *function) 2026 { 2027 static const int mult_fileset = 3; 2028 char fileset_name[SDCA_PROPERTY_LENGTH]; 2029 u32 *filesets_list __free(kfree) = NULL; 2030 struct sdca_fdl_set *sets; 2031 int num_sets; 2032 int i, j; 2033 2034 num_sets = fwnode_property_count_u32(function_node, 2035 "mipi-sdca-file-set-id-list"); 2036 if (num_sets == 0 || num_sets == -EINVAL) { 2037 return 0; 2038 } else if (num_sets < 0) { 2039 dev_err(dev, "%pfwP: failed to read file set list: %d\n", 2040 function_node, num_sets); 2041 return num_sets; 2042 } 2043 2044 filesets_list = kcalloc(num_sets, sizeof(u32), GFP_KERNEL); 2045 if (!filesets_list) 2046 return -ENOMEM; 2047 2048 fwnode_property_read_u32_array(function_node, "mipi-sdca-file-set-id-list", 2049 filesets_list, num_sets); 2050 2051 sets = devm_kcalloc(dev, num_sets, sizeof(struct sdca_fdl_set), GFP_KERNEL); 2052 if (!sets) 2053 return -ENOMEM; 2054 2055 for (i = 0; i < num_sets; i++) { 2056 u32 *fileset_entries __free(kfree) = NULL; 2057 struct sdca_fdl_set *set = &sets[i]; 2058 struct sdca_fdl_file *files; 2059 int num_files, num_entries; 2060 2061 snprintf(fileset_name, sizeof(fileset_name), 2062 "mipi-sdca-file-set-id-0x%X", filesets_list[i]); 2063 2064 num_entries = fwnode_property_count_u32(function_node, fileset_name); 2065 if (num_entries <= 0) { 2066 dev_err(dev, "%pfwP: file set %d missing entries: %d\n", 2067 function_node, filesets_list[i], num_entries); 2068 return -EINVAL; 2069 } else if (num_entries % mult_fileset != 0) { 2070 dev_err(dev, "%pfwP: file set %d files not multiple of %d\n", 2071 function_node, filesets_list[i], mult_fileset); 2072 return -EINVAL; 2073 } 2074 2075 dev_dbg(dev, "fileset: %#x\n", filesets_list[i]); 2076 2077 files = devm_kcalloc(dev, num_entries / mult_fileset, 2078 sizeof(struct sdca_fdl_file), GFP_KERNEL); 2079 if (!files) 2080 return -ENOMEM; 2081 2082 fileset_entries = kcalloc(num_entries, sizeof(u32), GFP_KERNEL); 2083 if (!fileset_entries) 2084 return -ENOMEM; 2085 2086 fwnode_property_read_u32_array(function_node, fileset_name, 2087 fileset_entries, num_entries); 2088 2089 for (j = 0, num_files = 0; j < num_entries; num_files++) { 2090 struct sdca_fdl_file *file = &files[num_files]; 2091 2092 file->vendor_id = fileset_entries[j++]; 2093 file->file_id = fileset_entries[j++]; 2094 file->fdl_offset = fileset_entries[j++]; 2095 2096 dev_dbg(dev, "file: %#x, vendor: %#x, offset: %#x\n", 2097 file->file_id, file->vendor_id, file->fdl_offset); 2098 } 2099 2100 set->id = filesets_list[i]; 2101 set->num_files = num_files; 2102 set->files = files; 2103 } 2104 2105 function->fdl_data.swft = sdw->sdca_data.swft; 2106 function->fdl_data.num_sets = num_sets; 2107 function->fdl_data.sets = sets; 2108 2109 return 0; 2110 } 2111 2112 /** 2113 * sdca_parse_function - parse ACPI DisCo for a Function 2114 * @dev: Pointer to device against which function data will be allocated. 2115 * @sdw: SoundWire slave device to be processed. 2116 * @function_desc: Pointer to the Function short descriptor. 2117 * @function: Pointer to the Function information, to be populated. 2118 * 2119 * Return: Returns 0 for success. 2120 */ 2121 int sdca_parse_function(struct device *dev, struct sdw_slave *sdw, 2122 struct sdca_function_desc *function_desc, 2123 struct sdca_function_data *function) 2124 { 2125 u32 tmp; 2126 int ret; 2127 2128 function->desc = function_desc; 2129 2130 ret = fwnode_property_read_u32(function_desc->node, 2131 "mipi-sdca-function-busy-max-delay", &tmp); 2132 if (!ret) 2133 function->busy_max_delay = tmp; 2134 2135 ret = fwnode_property_read_u32(function_desc->node, 2136 "mipi-sdca-function-reset-max-delay", &tmp); 2137 if (!ret) 2138 function->reset_max_delay = tmp; 2139 2140 dev_dbg(dev, "%pfwP: name %s busy delay %dus reset delay %dus\n", 2141 function->desc->node, function->desc->name, 2142 function->busy_max_delay, function->reset_max_delay); 2143 2144 ret = find_sdca_init_table(dev, function_desc->node, function); 2145 if (ret) 2146 return ret; 2147 2148 ret = find_sdca_entities(dev, sdw, function_desc->node, function); 2149 if (ret) 2150 return ret; 2151 2152 ret = find_sdca_connections(dev, function_desc->node, function); 2153 if (ret) 2154 return ret; 2155 2156 ret = find_sdca_clusters(dev, function_desc->node, function); 2157 if (ret < 0) 2158 return ret; 2159 2160 ret = find_sdca_filesets(dev, sdw, function_desc->node, function); 2161 if (ret) 2162 return ret; 2163 2164 return 0; 2165 } 2166 EXPORT_SYMBOL_NS(sdca_parse_function, "SND_SOC_SDCA"); 2167 2168 const char *sdca_find_terminal_name(enum sdca_terminal_type type) 2169 { 2170 switch (type) { 2171 case SDCA_TERM_TYPE_LINEIN_STEREO: 2172 return SDCA_TERM_TYPE_LINEIN_STEREO_NAME; 2173 case SDCA_TERM_TYPE_LINEIN_FRONT_LR: 2174 return SDCA_TERM_TYPE_LINEIN_FRONT_LR_NAME; 2175 case SDCA_TERM_TYPE_LINEIN_CENTER_LFE: 2176 return SDCA_TERM_TYPE_LINEIN_CENTER_LFE_NAME; 2177 case SDCA_TERM_TYPE_LINEIN_SURROUND_LR: 2178 return SDCA_TERM_TYPE_LINEIN_SURROUND_LR_NAME; 2179 case SDCA_TERM_TYPE_LINEIN_REAR_LR: 2180 return SDCA_TERM_TYPE_LINEIN_REAR_LR_NAME; 2181 case SDCA_TERM_TYPE_LINEOUT_STEREO: 2182 return SDCA_TERM_TYPE_LINEOUT_STEREO_NAME; 2183 case SDCA_TERM_TYPE_LINEOUT_FRONT_LR: 2184 return SDCA_TERM_TYPE_LINEOUT_FRONT_LR_NAME; 2185 case SDCA_TERM_TYPE_LINEOUT_CENTER_LFE: 2186 return SDCA_TERM_TYPE_LINEOUT_CENTER_LFE_NAME; 2187 case SDCA_TERM_TYPE_LINEOUT_SURROUND_LR: 2188 return SDCA_TERM_TYPE_LINEOUT_SURROUND_LR_NAME; 2189 case SDCA_TERM_TYPE_LINEOUT_REAR_LR: 2190 return SDCA_TERM_TYPE_LINEOUT_REAR_LR_NAME; 2191 case SDCA_TERM_TYPE_MIC_JACK: 2192 return SDCA_TERM_TYPE_MIC_JACK_NAME; 2193 case SDCA_TERM_TYPE_STEREO_JACK: 2194 return SDCA_TERM_TYPE_STEREO_JACK_NAME; 2195 case SDCA_TERM_TYPE_FRONT_LR_JACK: 2196 return SDCA_TERM_TYPE_FRONT_LR_JACK_NAME; 2197 case SDCA_TERM_TYPE_CENTER_LFE_JACK: 2198 return SDCA_TERM_TYPE_CENTER_LFE_JACK_NAME; 2199 case SDCA_TERM_TYPE_SURROUND_LR_JACK: 2200 return SDCA_TERM_TYPE_SURROUND_LR_JACK_NAME; 2201 case SDCA_TERM_TYPE_REAR_LR_JACK: 2202 return SDCA_TERM_TYPE_REAR_LR_JACK_NAME; 2203 case SDCA_TERM_TYPE_HEADPHONE_JACK: 2204 return SDCA_TERM_TYPE_HEADPHONE_JACK_NAME; 2205 case SDCA_TERM_TYPE_HEADSET_JACK: 2206 return SDCA_TERM_TYPE_HEADSET_JACK_NAME; 2207 default: 2208 return NULL; 2209 } 2210 } 2211 EXPORT_SYMBOL_NS(sdca_find_terminal_name, "SND_SOC_SDCA"); 2212 2213 struct sdca_control *sdca_selector_find_control(struct device *dev, 2214 struct sdca_entity *entity, 2215 const int sel) 2216 { 2217 int i; 2218 2219 for (i = 0; i < entity->num_controls; i++) { 2220 struct sdca_control *control = &entity->controls[i]; 2221 2222 if (control->sel == sel) 2223 return control; 2224 } 2225 2226 dev_err(dev, "%s: control %#x: missing\n", entity->label, sel); 2227 return NULL; 2228 } 2229 EXPORT_SYMBOL_NS(sdca_selector_find_control, "SND_SOC_SDCA"); 2230 2231 struct sdca_control_range *sdca_control_find_range(struct device *dev, 2232 struct sdca_entity *entity, 2233 struct sdca_control *control, 2234 int cols, int rows) 2235 { 2236 struct sdca_control_range *range = &control->range; 2237 2238 if ((cols && range->cols != cols) || (rows && range->rows != rows) || 2239 !range->data) { 2240 dev_err(dev, "%s: control %#x: ranges invalid (%d,%d)\n", 2241 entity->label, control->sel, range->cols, range->rows); 2242 return NULL; 2243 } 2244 2245 return range; 2246 } 2247 EXPORT_SYMBOL_NS(sdca_control_find_range, "SND_SOC_SDCA"); 2248 2249 struct sdca_control_range *sdca_selector_find_range(struct device *dev, 2250 struct sdca_entity *entity, 2251 int sel, int cols, int rows) 2252 { 2253 struct sdca_control *control; 2254 2255 control = sdca_selector_find_control(dev, entity, sel); 2256 if (!control) 2257 return NULL; 2258 2259 return sdca_control_find_range(dev, entity, control, cols, rows); 2260 } 2261 EXPORT_SYMBOL_NS(sdca_selector_find_range, "SND_SOC_SDCA"); 2262 2263 struct sdca_cluster *sdca_id_find_cluster(struct device *dev, 2264 struct sdca_function_data *function, 2265 const int id) 2266 { 2267 int i; 2268 2269 for (i = 0; i < function->num_clusters; i++) { 2270 struct sdca_cluster *cluster = &function->clusters[i]; 2271 2272 if (cluster->id == id) 2273 return cluster; 2274 } 2275 2276 dev_err(dev, "%s: cluster %#x: missing\n", function->desc->name, id); 2277 return NULL; 2278 } 2279 EXPORT_SYMBOL_NS(sdca_id_find_cluster, "SND_SOC_SDCA"); 2280 2281 MODULE_LICENSE("Dual BSD/GPL"); 2282 MODULE_DESCRIPTION("SDCA library"); 2283