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