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