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