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