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 / sizeof(*raw)) > 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 fallthrough; 885 case SDCA_ACCESS_MODE_RO: 886 control->deferrable = fwnode_property_read_bool(control_node, 887 "mipi-sdca-control-deferrable"); 888 break; 889 default: 890 break; 891 } 892 893 ret = find_sdca_control_range(dev, control_node, &control->range); 894 if (ret) { 895 dev_err(dev, "%s: control %#x: range missing: %d\n", 896 entity->label, control->sel, ret); 897 return ret; 898 } 899 900 ret = fwnode_property_read_u64(control_node, "mipi-sdca-control-cn-list", 901 &control->cn_list); 902 if (ret == -EINVAL) { 903 /* Spec allows not specifying cn-list if only the first number is used */ 904 control->cn_list = 0x1; 905 } else if (ret || !control->cn_list) { 906 dev_err(dev, "%s: control %#x: cn list missing: %d\n", 907 entity->label, control->sel, ret); 908 return ret; 909 } 910 911 ret = fwnode_property_read_u32(control_node, 912 "mipi-sdca-control-interrupt-position", 913 &tmp); 914 if (!ret) 915 control->interrupt_position = tmp; 916 else 917 control->interrupt_position = SDCA_NO_INTERRUPT; 918 919 control->label = find_sdca_control_label(dev, entity, control); 920 if (!control->label) 921 return -ENOMEM; 922 923 control->type = find_sdca_control_datatype(entity, control); 924 control->nbits = find_sdca_control_bits(entity, control); 925 926 dev_info(dev, "%s: %s: control %#x mode %#x layers %#x cn %#llx int %d value %#x %s\n", 927 entity->label, control->label, control->sel, 928 control->mode, control->layers, control->cn_list, 929 control->interrupt_position, control->value, 930 control->deferrable ? "deferrable" : ""); 931 932 return 0; 933 } 934 935 static int find_sdca_entity_controls(struct device *dev, 936 struct fwnode_handle *entity_node, 937 struct sdca_entity *entity) 938 { 939 struct sdca_control *controls; 940 int num_controls; 941 u64 control_list; 942 int control_sel; 943 int i, ret; 944 945 ret = fwnode_property_read_u64(entity_node, "mipi-sdca-control-list", &control_list); 946 if (ret == -EINVAL) { 947 /* Allow missing control lists, assume no controls. */ 948 dev_warn(dev, "%s: missing control list\n", entity->label); 949 return 0; 950 } else if (ret) { 951 dev_err(dev, "%s: failed to read control list: %d\n", entity->label, ret); 952 return ret; 953 } else if (!control_list) { 954 return 0; 955 } 956 957 num_controls = hweight64(control_list); 958 controls = devm_kcalloc(dev, num_controls, sizeof(*controls), GFP_KERNEL); 959 if (!controls) 960 return -ENOMEM; 961 962 i = 0; 963 for_each_set_bit(control_sel, (unsigned long *)&control_list, 964 BITS_PER_TYPE(control_list)) { 965 struct fwnode_handle *control_node; 966 char control_property[SDCA_PROPERTY_LENGTH]; 967 968 /* DisCo uses upper-case for hex numbers */ 969 snprintf(control_property, sizeof(control_property), 970 "mipi-sdca-control-0x%X-subproperties", control_sel); 971 972 control_node = fwnode_get_named_child_node(entity_node, control_property); 973 if (!control_node) { 974 dev_err(dev, "%s: control node %s not found\n", 975 entity->label, control_property); 976 return -EINVAL; 977 } 978 979 controls[i].sel = control_sel; 980 981 ret = find_sdca_entity_control(dev, entity, control_node, &controls[i]); 982 fwnode_handle_put(control_node); 983 if (ret) 984 return ret; 985 986 i++; 987 } 988 989 entity->num_controls = num_controls; 990 entity->controls = controls; 991 992 return 0; 993 } 994 995 static bool find_sdca_iot_dataport(struct sdca_entity_iot *terminal) 996 { 997 switch (terminal->type) { 998 case SDCA_TERM_TYPE_GENERIC: 999 case SDCA_TERM_TYPE_ULTRASOUND: 1000 case SDCA_TERM_TYPE_CAPTURE_DIRECT_PCM_MIC: 1001 case SDCA_TERM_TYPE_RAW_PDM_MIC: 1002 case SDCA_TERM_TYPE_SPEECH: 1003 case SDCA_TERM_TYPE_VOICE: 1004 case SDCA_TERM_TYPE_SECONDARY_PCM_MIC: 1005 case SDCA_TERM_TYPE_ACOUSTIC_CONTEXT_AWARENESS: 1006 case SDCA_TERM_TYPE_DTOD_STREAM: 1007 case SDCA_TERM_TYPE_REFERENCE_STREAM: 1008 case SDCA_TERM_TYPE_SENSE_CAPTURE: 1009 case SDCA_TERM_TYPE_STREAMING_MIC: 1010 case SDCA_TERM_TYPE_OPTIMIZATION_STREAM: 1011 case SDCA_TERM_TYPE_PDM_RENDER_STREAM: 1012 case SDCA_TERM_TYPE_COMPANION_DATA: 1013 return true; 1014 default: 1015 return false; 1016 } 1017 } 1018 1019 static int find_sdca_entity_iot(struct device *dev, 1020 struct fwnode_handle *entity_node, 1021 struct sdca_entity *entity) 1022 { 1023 struct sdca_entity_iot *terminal = &entity->iot; 1024 u32 tmp; 1025 int ret; 1026 1027 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-terminal-type", &tmp); 1028 if (ret) { 1029 dev_err(dev, "%s: terminal type missing: %d\n", entity->label, ret); 1030 return ret; 1031 } 1032 1033 terminal->type = tmp; 1034 terminal->is_dataport = find_sdca_iot_dataport(terminal); 1035 1036 ret = fwnode_property_read_u32(entity_node, 1037 "mipi-sdca-terminal-reference-number", &tmp); 1038 if (!ret) 1039 terminal->reference = tmp; 1040 1041 ret = fwnode_property_read_u32(entity_node, 1042 "mipi-sdca-terminal-connector-type", &tmp); 1043 if (!ret) 1044 terminal->connector = tmp; 1045 1046 ret = fwnode_property_read_u32(entity_node, 1047 "mipi-sdca-terminal-transducer-count", &tmp); 1048 if (!ret) 1049 terminal->num_transducer = tmp; 1050 1051 dev_info(dev, "%s: terminal type %#x ref %#x conn %#x count %d\n", 1052 entity->label, terminal->type, terminal->reference, 1053 terminal->connector, terminal->num_transducer); 1054 1055 return 0; 1056 } 1057 1058 static int find_sdca_entity_cs(struct device *dev, 1059 struct fwnode_handle *entity_node, 1060 struct sdca_entity *entity) 1061 { 1062 struct sdca_entity_cs *clock = &entity->cs; 1063 u32 tmp; 1064 int ret; 1065 1066 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-cs-type", &tmp); 1067 if (ret) { 1068 dev_err(dev, "%s: clock type missing: %d\n", entity->label, ret); 1069 return ret; 1070 } 1071 1072 clock->type = tmp; 1073 1074 ret = fwnode_property_read_u32(entity_node, 1075 "mipi-sdca-clock-valid-max-delay", &tmp); 1076 if (!ret) 1077 clock->max_delay = tmp; 1078 1079 dev_info(dev, "%s: clock type %#x delay %d\n", entity->label, 1080 clock->type, clock->max_delay); 1081 1082 return 0; 1083 } 1084 1085 static int find_sdca_entity_pde(struct device *dev, 1086 struct fwnode_handle *entity_node, 1087 struct sdca_entity *entity) 1088 { 1089 static const int mult_delay = 3; 1090 struct sdca_entity_pde *power = &entity->pde; 1091 u32 *delay_list __free(kfree) = NULL; 1092 struct sdca_pde_delay *delays; 1093 int num_delays; 1094 int i, j; 1095 1096 num_delays = fwnode_property_count_u32(entity_node, 1097 "mipi-sdca-powerdomain-transition-max-delay"); 1098 if (num_delays <= 0) { 1099 dev_err(dev, "%s: max delay list missing: %d\n", 1100 entity->label, num_delays); 1101 return -EINVAL; 1102 } else if (num_delays % mult_delay != 0) { 1103 dev_err(dev, "%s: delays not multiple of %d\n", 1104 entity->label, mult_delay); 1105 return -EINVAL; 1106 } else if (num_delays > SDCA_MAX_DELAY_COUNT) { 1107 dev_err(dev, "%s: maximum number of transition delays exceeded\n", 1108 entity->label); 1109 return -EINVAL; 1110 } 1111 1112 delay_list = kcalloc(num_delays, sizeof(*delay_list), GFP_KERNEL); 1113 if (!delay_list) 1114 return -ENOMEM; 1115 1116 fwnode_property_read_u32_array(entity_node, 1117 "mipi-sdca-powerdomain-transition-max-delay", 1118 delay_list, num_delays); 1119 1120 num_delays /= mult_delay; 1121 1122 delays = devm_kcalloc(dev, num_delays, sizeof(*delays), GFP_KERNEL); 1123 if (!delays) 1124 return -ENOMEM; 1125 1126 for (i = 0, j = 0; i < num_delays; i++) { 1127 delays[i].from_ps = delay_list[j++]; 1128 delays[i].to_ps = delay_list[j++]; 1129 delays[i].us = delay_list[j++]; 1130 1131 dev_info(dev, "%s: from %#x to %#x delay %dus\n", entity->label, 1132 delays[i].from_ps, delays[i].to_ps, delays[i].us); 1133 } 1134 1135 power->num_max_delay = num_delays; 1136 power->max_delay = delays; 1137 1138 return 0; 1139 } 1140 1141 struct raw_ge_mode { 1142 u8 val; 1143 u8 num_controls; 1144 struct { 1145 u8 id; 1146 u8 sel; 1147 u8 cn; 1148 __le32 val; 1149 } __packed controls[] __counted_by(num_controls); 1150 } __packed; 1151 1152 static int find_sdca_entity_ge(struct device *dev, 1153 struct fwnode_handle *entity_node, 1154 struct sdca_entity *entity) 1155 { 1156 struct sdca_entity_ge *group = &entity->ge; 1157 u8 *affected_list __free(kfree) = NULL; 1158 u8 *affected_iter; 1159 int num_affected; 1160 int i, j; 1161 1162 num_affected = fwnode_property_count_u8(entity_node, 1163 "mipi-sdca-ge-selectedmode-controls-affected"); 1164 if (!num_affected) { 1165 return 0; 1166 } else if (num_affected < 0) { 1167 dev_err(dev, "%s: failed to read affected controls: %d\n", 1168 entity->label, num_affected); 1169 return num_affected; 1170 } else if (num_affected > SDCA_MAX_AFFECTED_COUNT) { 1171 dev_err(dev, "%s: maximum affected controls size exceeded\n", 1172 entity->label); 1173 return -EINVAL; 1174 } 1175 1176 affected_list = kcalloc(num_affected, sizeof(*affected_list), GFP_KERNEL); 1177 if (!affected_list) 1178 return -ENOMEM; 1179 1180 fwnode_property_read_u8_array(entity_node, 1181 "mipi-sdca-ge-selectedmode-controls-affected", 1182 affected_list, num_affected); 1183 1184 group->num_modes = *affected_list; 1185 affected_iter = affected_list + 1; 1186 1187 group->modes = devm_kcalloc(dev, group->num_modes, sizeof(*group->modes), 1188 GFP_KERNEL); 1189 if (!group->modes) 1190 return -ENOMEM; 1191 1192 for (i = 0; i < group->num_modes; i++) { 1193 struct raw_ge_mode *raw = (struct raw_ge_mode *)affected_iter; 1194 struct sdca_ge_mode *mode = &group->modes[i]; 1195 1196 affected_iter += sizeof(*raw); 1197 if (affected_iter > affected_list + num_affected) 1198 goto bad_list; 1199 1200 mode->val = raw->val; 1201 mode->num_controls = raw->num_controls; 1202 1203 affected_iter += mode->num_controls * sizeof(raw->controls[0]); 1204 if (affected_iter > affected_list + num_affected) 1205 goto bad_list; 1206 1207 mode->controls = devm_kcalloc(dev, mode->num_controls, 1208 sizeof(*mode->controls), GFP_KERNEL); 1209 if (!mode->controls) 1210 return -ENOMEM; 1211 1212 for (j = 0; j < mode->num_controls; j++) { 1213 mode->controls[j].id = raw->controls[j].id; 1214 mode->controls[j].sel = raw->controls[j].sel; 1215 mode->controls[j].cn = raw->controls[j].cn; 1216 mode->controls[j].val = le32_to_cpu(raw->controls[j].val); 1217 } 1218 } 1219 1220 return 0; 1221 1222 bad_list: 1223 dev_err(dev, "%s: malformed affected controls list\n", entity->label); 1224 return -EINVAL; 1225 } 1226 1227 static int 1228 find_sdca_entity_hide(struct device *dev, struct fwnode_handle *function_node, 1229 struct fwnode_handle *entity_node, struct sdca_entity *entity) 1230 { 1231 struct sdca_entity_hide *hide = &entity->hide; 1232 unsigned int delay, *af_list = hide->af_number_list; 1233 int nval, ret; 1234 unsigned char *report_desc = NULL; 1235 1236 ret = fwnode_property_read_u32(entity_node, 1237 "mipi-sdca-RxUMP-ownership-transition-maxdelay", &delay); 1238 if (!ret) 1239 hide->max_delay = delay; 1240 1241 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDTx-supported-report-ids"); 1242 if (nval > 0) { 1243 hide->num_hidtx_ids = nval; 1244 hide->hidtx_ids = devm_kcalloc(dev, hide->num_hidtx_ids, 1245 sizeof(*hide->hidtx_ids), GFP_KERNEL); 1246 if (!hide->hidtx_ids) 1247 return -ENOMEM; 1248 1249 ret = fwnode_property_read_u32_array(entity_node, 1250 "mipi-sdca-HIDTx-supported-report-ids", 1251 hide->hidtx_ids, 1252 hide->num_hidtx_ids); 1253 if (ret < 0) 1254 return ret; 1255 } 1256 1257 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-HIDRx-supported-report-ids"); 1258 if (nval > 0) { 1259 hide->num_hidrx_ids = nval; 1260 hide->hidrx_ids = devm_kcalloc(dev, hide->num_hidrx_ids, 1261 sizeof(*hide->hidrx_ids), GFP_KERNEL); 1262 if (!hide->hidrx_ids) 1263 return -ENOMEM; 1264 1265 ret = fwnode_property_read_u32_array(entity_node, 1266 "mipi-sdca-HIDRx-supported-report-ids", 1267 hide->hidrx_ids, 1268 hide->num_hidrx_ids); 1269 if (ret < 0) 1270 return ret; 1271 } 1272 1273 nval = fwnode_property_count_u32(entity_node, "mipi-sdca-hide-related-audio-function-list"); 1274 if (nval <= 0) { 1275 dev_err(dev, "%pfwP: audio function numbers list missing: %d\n", 1276 entity_node, nval); 1277 return -EINVAL; 1278 } else if (nval > SDCA_MAX_FUNCTION_COUNT) { 1279 dev_err(dev, "%pfwP: maximum number of audio function exceeded\n", entity_node); 1280 return -EINVAL; 1281 } 1282 1283 hide->hide_reside_function_num = nval; 1284 fwnode_property_read_u32_array(entity_node, 1285 "mipi-sdca-hide-related-audio-function-list", af_list, nval); 1286 1287 nval = fwnode_property_count_u8(function_node, "mipi-sdca-hid-descriptor"); 1288 if (nval) 1289 fwnode_property_read_u8_array(function_node, "mipi-sdca-hid-descriptor", 1290 (u8 *)&hide->hid_desc, nval); 1291 1292 if (hide->hid_desc.bNumDescriptors) { 1293 nval = fwnode_property_count_u8(function_node, "mipi-sdca-report-descriptor"); 1294 if (nval) { 1295 report_desc = devm_kzalloc(dev, nval, GFP_KERNEL); 1296 if (!report_desc) 1297 return -ENOMEM; 1298 hide->hid_report_desc = report_desc; 1299 fwnode_property_read_u8_array(function_node, "mipi-sdca-report-descriptor", 1300 report_desc, nval); 1301 1302 /* add HID device */ 1303 ret = sdca_add_hid_device(dev, entity); 1304 if (ret) { 1305 dev_err(dev, "%pfwP: failed to add HID device: %d\n", entity_node, ret); 1306 return ret; 1307 } 1308 } 1309 } 1310 1311 return 0; 1312 } 1313 1314 static int find_sdca_entity(struct device *dev, 1315 struct fwnode_handle *function_node, 1316 struct fwnode_handle *entity_node, 1317 struct sdca_entity *entity) 1318 { 1319 u32 tmp; 1320 int ret; 1321 1322 ret = fwnode_property_read_string(entity_node, "mipi-sdca-entity-label", 1323 &entity->label); 1324 if (ret) { 1325 dev_err(dev, "%pfwP: entity %#x: label missing: %d\n", 1326 function_node, entity->id, ret); 1327 return ret; 1328 } 1329 1330 ret = fwnode_property_read_u32(entity_node, "mipi-sdca-entity-type", &tmp); 1331 if (ret) { 1332 dev_err(dev, "%s: type missing: %d\n", entity->label, ret); 1333 return ret; 1334 } 1335 1336 entity->type = tmp; 1337 1338 dev_info(dev, "%s: entity %#x type %#x\n", 1339 entity->label, entity->id, entity->type); 1340 1341 switch (entity->type) { 1342 case SDCA_ENTITY_TYPE_IT: 1343 case SDCA_ENTITY_TYPE_OT: 1344 ret = find_sdca_entity_iot(dev, entity_node, entity); 1345 break; 1346 case SDCA_ENTITY_TYPE_CS: 1347 ret = find_sdca_entity_cs(dev, entity_node, entity); 1348 break; 1349 case SDCA_ENTITY_TYPE_PDE: 1350 ret = find_sdca_entity_pde(dev, entity_node, entity); 1351 break; 1352 case SDCA_ENTITY_TYPE_GE: 1353 ret = find_sdca_entity_ge(dev, entity_node, entity); 1354 break; 1355 case SDCA_ENTITY_TYPE_HIDE: 1356 ret = find_sdca_entity_hide(dev, function_node, entity_node, entity); 1357 break; 1358 default: 1359 break; 1360 } 1361 if (ret) 1362 return ret; 1363 1364 ret = find_sdca_entity_controls(dev, entity_node, entity); 1365 if (ret) 1366 return ret; 1367 1368 return 0; 1369 } 1370 1371 static int find_sdca_entities(struct device *dev, 1372 struct fwnode_handle *function_node, 1373 struct sdca_function_data *function) 1374 { 1375 u32 *entity_list __free(kfree) = NULL; 1376 struct sdca_entity *entities; 1377 int num_entities; 1378 int i, ret; 1379 1380 num_entities = fwnode_property_count_u32(function_node, 1381 "mipi-sdca-entity-id-list"); 1382 if (num_entities <= 0) { 1383 dev_err(dev, "%pfwP: entity id list missing: %d\n", 1384 function_node, num_entities); 1385 return -EINVAL; 1386 } else if (num_entities > SDCA_MAX_ENTITY_COUNT) { 1387 dev_err(dev, "%pfwP: maximum number of entities exceeded\n", 1388 function_node); 1389 return -EINVAL; 1390 } 1391 1392 /* Add 1 to make space for Entity 0 */ 1393 entities = devm_kcalloc(dev, num_entities + 1, sizeof(*entities), GFP_KERNEL); 1394 if (!entities) 1395 return -ENOMEM; 1396 1397 entity_list = kcalloc(num_entities, sizeof(*entity_list), GFP_KERNEL); 1398 if (!entity_list) 1399 return -ENOMEM; 1400 1401 fwnode_property_read_u32_array(function_node, "mipi-sdca-entity-id-list", 1402 entity_list, num_entities); 1403 1404 for (i = 0; i < num_entities; i++) 1405 entities[i].id = entity_list[i]; 1406 1407 /* now read subproperties */ 1408 for (i = 0; i < num_entities; i++) { 1409 char entity_property[SDCA_PROPERTY_LENGTH]; 1410 struct fwnode_handle *entity_node; 1411 1412 /* DisCo uses upper-case for hex numbers */ 1413 snprintf(entity_property, sizeof(entity_property), 1414 "mipi-sdca-entity-id-0x%X-subproperties", entities[i].id); 1415 1416 entity_node = fwnode_get_named_child_node(function_node, entity_property); 1417 if (!entity_node) { 1418 dev_err(dev, "%pfwP: entity node %s not found\n", 1419 function_node, entity_property); 1420 return -EINVAL; 1421 } 1422 1423 ret = find_sdca_entity(dev, function_node, entity_node, &entities[i]); 1424 fwnode_handle_put(entity_node); 1425 if (ret) 1426 return ret; 1427 } 1428 1429 /* 1430 * Add Entity 0 at end of the array, makes it easy to skip during 1431 * all the Entity searches involved in creating connections. 1432 */ 1433 entities[num_entities].label = "entity0"; 1434 1435 ret = find_sdca_entity_controls(dev, function_node, &entities[num_entities]); 1436 if (ret) 1437 return ret; 1438 1439 function->num_entities = num_entities + 1; 1440 function->entities = entities; 1441 1442 return 0; 1443 } 1444 1445 static struct sdca_entity *find_sdca_entity_by_label(struct sdca_function_data *function, 1446 const char *entity_label) 1447 { 1448 int i; 1449 1450 for (i = 0; i < function->num_entities; i++) { 1451 struct sdca_entity *entity = &function->entities[i]; 1452 1453 if (!strcmp(entity->label, entity_label)) 1454 return entity; 1455 } 1456 1457 return NULL; 1458 } 1459 1460 static struct sdca_entity *find_sdca_entity_by_id(struct sdca_function_data *function, 1461 const int id) 1462 { 1463 int i; 1464 1465 for (i = 0; i < function->num_entities; i++) { 1466 struct sdca_entity *entity = &function->entities[i]; 1467 1468 if (entity->id == id) 1469 return entity; 1470 } 1471 1472 return NULL; 1473 } 1474 1475 static int find_sdca_entity_connection_iot(struct device *dev, 1476 struct sdca_function_data *function, 1477 struct fwnode_handle *entity_node, 1478 struct sdca_entity *entity) 1479 { 1480 struct sdca_entity_iot *terminal = &entity->iot; 1481 struct fwnode_handle *clock_node; 1482 struct sdca_entity *clock_entity; 1483 const char *clock_label; 1484 int ret; 1485 1486 clock_node = fwnode_get_named_child_node(entity_node, 1487 "mipi-sdca-terminal-clock-connection"); 1488 if (!clock_node) 1489 return 0; 1490 1491 ret = fwnode_property_read_string(clock_node, "mipi-sdca-entity-label", 1492 &clock_label); 1493 if (ret) { 1494 dev_err(dev, "%s: clock label missing: %d\n", entity->label, ret); 1495 fwnode_handle_put(clock_node); 1496 return ret; 1497 } 1498 1499 clock_entity = find_sdca_entity_by_label(function, clock_label); 1500 if (!clock_entity) { 1501 dev_err(dev, "%s: failed to find clock with label %s\n", 1502 entity->label, clock_label); 1503 fwnode_handle_put(clock_node); 1504 return -EINVAL; 1505 } 1506 1507 terminal->clock = clock_entity; 1508 1509 dev_info(dev, "%s -> %s\n", clock_entity->label, entity->label); 1510 1511 fwnode_handle_put(clock_node); 1512 return 0; 1513 } 1514 1515 static int find_sdca_entity_connection_pde(struct device *dev, 1516 struct sdca_function_data *function, 1517 struct fwnode_handle *entity_node, 1518 struct sdca_entity *entity) 1519 { 1520 struct sdca_entity_pde *power = &entity->pde; 1521 u32 *managed_list __free(kfree) = NULL; 1522 struct sdca_entity **managed; 1523 int num_managed; 1524 int i; 1525 1526 num_managed = fwnode_property_count_u32(entity_node, 1527 "mipi-sdca-powerdomain-managed-list"); 1528 if (!num_managed) { 1529 return 0; 1530 } else if (num_managed < 0) { 1531 dev_err(dev, "%s: managed list missing: %d\n", entity->label, num_managed); 1532 return num_managed; 1533 } else if (num_managed > SDCA_MAX_ENTITY_COUNT) { 1534 dev_err(dev, "%s: maximum number of managed entities exceeded\n", 1535 entity->label); 1536 return -EINVAL; 1537 } 1538 1539 managed = devm_kcalloc(dev, num_managed, sizeof(*managed), GFP_KERNEL); 1540 if (!managed) 1541 return -ENOMEM; 1542 1543 managed_list = kcalloc(num_managed, sizeof(*managed_list), GFP_KERNEL); 1544 if (!managed_list) 1545 return -ENOMEM; 1546 1547 fwnode_property_read_u32_array(entity_node, 1548 "mipi-sdca-powerdomain-managed-list", 1549 managed_list, num_managed); 1550 1551 for (i = 0; i < num_managed; i++) { 1552 managed[i] = find_sdca_entity_by_id(function, managed_list[i]); 1553 if (!managed[i]) { 1554 dev_err(dev, "%s: failed to find entity with id %#x\n", 1555 entity->label, managed_list[i]); 1556 return -EINVAL; 1557 } 1558 1559 dev_info(dev, "%s -> %s\n", managed[i]->label, entity->label); 1560 } 1561 1562 power->num_managed = num_managed; 1563 power->managed = managed; 1564 1565 return 0; 1566 } 1567 1568 static int find_sdca_entity_connection_ge(struct device *dev, 1569 struct sdca_function_data *function, 1570 struct fwnode_handle *entity_node, 1571 struct sdca_entity *entity) 1572 { 1573 int i, j; 1574 1575 for (i = 0; i < entity->ge.num_modes; i++) { 1576 struct sdca_ge_mode *mode = &entity->ge.modes[i]; 1577 1578 for (j = 0; j < mode->num_controls; j++) { 1579 struct sdca_ge_control *affected = &mode->controls[j]; 1580 struct sdca_entity *managed; 1581 1582 managed = find_sdca_entity_by_id(function, affected->id); 1583 if (!managed) { 1584 dev_err(dev, "%s: failed to find entity with id %#x\n", 1585 entity->label, affected->id); 1586 return -EINVAL; 1587 } 1588 1589 if (managed->group && managed->group != entity) { 1590 dev_err(dev, 1591 "%s: entity controlled by two groups %s, %s\n", 1592 managed->label, managed->group->label, 1593 entity->label); 1594 return -EINVAL; 1595 } 1596 1597 managed->group = entity; 1598 } 1599 } 1600 1601 return 0; 1602 } 1603 1604 static int find_sdca_entity_connection(struct device *dev, 1605 struct sdca_function_data *function, 1606 struct fwnode_handle *entity_node, 1607 struct sdca_entity *entity) 1608 { 1609 struct sdca_entity **pins; 1610 int num_pins, pin; 1611 u64 pin_list; 1612 int i, ret; 1613 1614 switch (entity->type) { 1615 case SDCA_ENTITY_TYPE_IT: 1616 case SDCA_ENTITY_TYPE_OT: 1617 ret = find_sdca_entity_connection_iot(dev, function, 1618 entity_node, entity); 1619 break; 1620 case SDCA_ENTITY_TYPE_PDE: 1621 ret = find_sdca_entity_connection_pde(dev, function, 1622 entity_node, entity); 1623 break; 1624 case SDCA_ENTITY_TYPE_GE: 1625 ret = find_sdca_entity_connection_ge(dev, function, 1626 entity_node, entity); 1627 break; 1628 default: 1629 ret = 0; 1630 break; 1631 } 1632 if (ret) 1633 return ret; 1634 1635 ret = fwnode_property_read_u64(entity_node, "mipi-sdca-input-pin-list", &pin_list); 1636 if (ret == -EINVAL) { 1637 /* Allow missing pin lists, assume no pins. */ 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 struct sdca_control *sdca_selector_find_control(struct device *dev, 1945 struct sdca_entity *entity, 1946 const int sel) 1947 { 1948 int i; 1949 1950 for (i = 0; i < entity->num_controls; i++) { 1951 struct sdca_control *control = &entity->controls[i]; 1952 1953 if (control->sel == sel) 1954 return control; 1955 } 1956 1957 dev_err(dev, "%s: control %#x: missing\n", entity->label, sel); 1958 return NULL; 1959 } 1960 EXPORT_SYMBOL_NS(sdca_selector_find_control, "SND_SOC_SDCA"); 1961 1962 struct sdca_control_range *sdca_control_find_range(struct device *dev, 1963 struct sdca_entity *entity, 1964 struct sdca_control *control, 1965 int cols, int rows) 1966 { 1967 struct sdca_control_range *range = &control->range; 1968 1969 if ((cols && range->cols != cols) || (rows && range->rows != rows) || 1970 !range->data) { 1971 dev_err(dev, "%s: control %#x: ranges invalid (%d,%d)\n", 1972 entity->label, control->sel, range->cols, range->rows); 1973 return NULL; 1974 } 1975 1976 return range; 1977 } 1978 EXPORT_SYMBOL_NS(sdca_control_find_range, "SND_SOC_SDCA"); 1979 1980 struct sdca_control_range *sdca_selector_find_range(struct device *dev, 1981 struct sdca_entity *entity, 1982 int sel, int cols, int rows) 1983 { 1984 struct sdca_control *control; 1985 1986 control = sdca_selector_find_control(dev, entity, sel); 1987 if (!control) 1988 return NULL; 1989 1990 return sdca_control_find_range(dev, entity, control, cols, rows); 1991 } 1992 EXPORT_SYMBOL_NS(sdca_selector_find_range, "SND_SOC_SDCA"); 1993 1994 struct sdca_cluster *sdca_id_find_cluster(struct device *dev, 1995 struct sdca_function_data *function, 1996 const int id) 1997 { 1998 int i; 1999 2000 for (i = 0; i < function->num_clusters; i++) { 2001 struct sdca_cluster *cluster = &function->clusters[i]; 2002 2003 if (cluster->id == id) 2004 return cluster; 2005 } 2006 2007 dev_err(dev, "%s: cluster %#x: missing\n", function->desc->name, id); 2008 return NULL; 2009 } 2010 EXPORT_SYMBOL_NS(sdca_id_find_cluster, "SND_SOC_SDCA"); 2011 2012 MODULE_LICENSE("Dual BSD/GPL"); 2013 MODULE_DESCRIPTION("SDCA library"); 2014