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