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