1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // CS35l41 ALSA HDA audio driver 4 // 5 // Copyright 2021 Cirrus Logic, Inc. 6 // 7 // Author: Lucas Tanure <tanureal@opensource.cirrus.com> 8 9 #include <linux/acpi.h> 10 #include <linux/module.h> 11 #include <linux/moduleparam.h> 12 #include <sound/hda_codec.h> 13 #include <sound/soc.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/spi/spi.h> 16 #include <linux/vmalloc.h> 17 #include "hda_local.h" 18 #include "hda_auto_parser.h" 19 #include "hda_jack.h" 20 #include "../generic.h" 21 #include "hda_component.h" 22 #include "cs35l41_hda.h" 23 #include "cs35l41_hda_property.h" 24 25 #define CS35L41_PART "cs35l41" 26 27 #define HALO_STATE_DSP_CTL_NAME "HALO_STATE" 28 #define HALO_STATE_DSP_CTL_TYPE 5 29 #define HALO_STATE_DSP_CTL_ALG 262308 30 #define CAL_R_DSP_CTL_NAME "CAL_R" 31 #define CAL_STATUS_DSP_CTL_NAME "CAL_STATUS" 32 #define CAL_CHECKSUM_DSP_CTL_NAME "CAL_CHECKSUM" 33 #define CAL_AMBIENT_DSP_CTL_NAME "CAL_AMBIENT" 34 #define CAL_DSP_CTL_TYPE 5 35 #define CAL_DSP_CTL_ALG 205 36 #define CS35L41_UUID "50d90cdc-3de4-4f18-b528-c7fe3b71f40d" 37 #define CS35L41_DSM_GET_MUTE 5 38 #define CS35L41_NOTIFY_EVENT 0x91 39 #define CS35L41_TUNING_SIG 0x109A4A35 40 41 enum cs35l41_tuning_param_types { 42 TUNING_PARAM_GAIN, 43 }; 44 45 struct cs35l41_tuning_param_hdr { 46 __le32 tuning_index; 47 __le32 type; 48 __le32 size; 49 } __packed; 50 51 struct cs35l41_tuning_param { 52 struct cs35l41_tuning_param_hdr hdr; 53 union { 54 __le32 gain; 55 }; 56 } __packed; 57 58 struct cs35l41_tuning_params { 59 __le32 signature; 60 __le32 version; 61 __le32 size; 62 __le32 num_entries; 63 u8 data[]; 64 } __packed; 65 66 /* Firmware calibration controls */ 67 static const struct cirrus_amp_cal_controls cs35l41_calibration_controls = { 68 .alg_id = CAL_DSP_CTL_ALG, 69 .mem_region = CAL_DSP_CTL_TYPE, 70 .ambient = CAL_AMBIENT_DSP_CTL_NAME, 71 .calr = CAL_R_DSP_CTL_NAME, 72 .status = CAL_STATUS_DSP_CTL_NAME, 73 .checksum = CAL_CHECKSUM_DSP_CTL_NAME, 74 }; 75 76 enum cs35l41_hda_fw_id { 77 CS35L41_HDA_FW_SPK_PROT, 78 CS35L41_HDA_FW_SPK_CALI, 79 CS35L41_HDA_FW_SPK_DIAG, 80 CS35L41_HDA_FW_MISC, 81 CS35L41_HDA_NUM_FW 82 }; 83 84 static const char * const cs35l41_hda_fw_ids[CS35L41_HDA_NUM_FW] = { 85 [CS35L41_HDA_FW_SPK_PROT] = "spk-prot", 86 [CS35L41_HDA_FW_SPK_CALI] = "spk-cali", 87 [CS35L41_HDA_FW_SPK_DIAG] = "spk-diag", 88 [CS35L41_HDA_FW_MISC] = "misc", 89 }; 90 91 static bool firmware_autostart = 1; 92 module_param(firmware_autostart, bool, 0444); 93 MODULE_PARM_DESC(firmware_autostart, "Allow automatic firmware download on boot" 94 "(0=Disable, 1=Enable) (default=1); "); 95 96 static const char channel_name[3] = { 'L', 'R', 'C' }; 97 98 static const struct reg_sequence cs35l41_hda_config[] = { 99 { CS35L41_PLL_CLK_CTRL, 0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1 100 { CS35L41_DSP_CLK_CTRL, 0x00000003 }, // DSP CLK EN 101 { CS35L41_GLOBAL_CLK_CTRL, 0x00000003 }, // GLOBAL_FS = 48 kHz 102 { CS35L41_SP_RATE_CTRL, 0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz 103 { CS35L41_SP_FORMAT, 0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer 104 { CS35L41_SP_TX_WL, 0x00000018 }, // 24 cycles/slot 105 { CS35L41_SP_RX_WL, 0x00000018 }, // 24 cycles/slot 106 { CS35L41_ASP_TX1_SRC, 0x00000018 }, // ASPTX1 SRC = VMON 107 { CS35L41_ASP_TX2_SRC, 0x00000019 }, // ASPTX2 SRC = IMON 108 { CS35L41_DSP1_RX3_SRC, 0x00000018 }, // DSP1RX3 SRC = VMON 109 { CS35L41_DSP1_RX4_SRC, 0x00000019 }, // DSP1RX4 SRC = IMON 110 }; 111 112 static const struct reg_sequence cs35l41_hda_config_no_dsp[] = { 113 { CS35L41_SP_HIZ_CTRL, 0x00000002 }, // Hi-Z unused 114 { CS35L41_DAC_PCM1_SRC, 0x00000008 }, // DACPCM1_SRC = ASPRX1 115 { CS35L41_ASP_TX3_SRC, 0x00000000 }, // ASPTX3 SRC = ZERO FILL 116 { CS35L41_ASP_TX4_SRC, 0x00000000 }, // ASPTX4 SRC = ZERO FILL 117 { CS35L41_DSP1_RX5_SRC, 0x00000020 }, // DSP1RX5 SRC = ERRVOL 118 { CS35L41_DSP1_RX6_SRC, 0x00000021 }, // DSP1RX6 SRC = CLASSH_TGT 119 }; 120 121 static const struct reg_sequence cs35l41_hda_config_dsp[] = { 122 { CS35L41_SP_HIZ_CTRL, 0x00000003 }, // Hi-Z unused/disabled 123 { CS35L41_DAC_PCM1_SRC, 0x00000032 }, // DACPCM1_SRC = DSP1TX1 124 { CS35L41_ASP_TX3_SRC, 0x00000028 }, // ASPTX3 SRC = VPMON 125 { CS35L41_ASP_TX4_SRC, 0x00000029 }, // ASPTX4 SRC = VBSTMON 126 { CS35L41_DSP1_RX6_SRC, 0x00000029 }, // DSP1RX6 SRC = VBSTMON 127 }; 128 129 static const struct reg_sequence cs35l41_hda_unmute[] = { 130 { CS35L41_AMP_DIG_VOL_CTRL, 0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM 0.0 dB 131 { CS35L41_AMP_GAIN_CTRL, 0x00000084 }, // AMP_GAIN_PCM 4.5 dB 132 }; 133 134 static const struct reg_sequence cs35l41_hda_mute[] = { 135 { CS35L41_AMP_GAIN_CTRL, 0x00000000 }, // AMP_GAIN_PCM 0.5 dB 136 { CS35L41_AMP_DIG_VOL_CTRL, 0x0000A678 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM Mute 137 }; 138 139 static const struct cs_dsp_client_ops client_ops = { 140 /* cs_dsp requires the client to provide this even if it is empty */ 141 }; 142 143 static int cs35l41_request_tuning_param_file(struct cs35l41_hda *cs35l41, char *tuning_filename, 144 const struct firmware **firmware, char **filename, 145 const char *ssid) 146 { 147 int ret = 0; 148 149 /* Filename is the same as the tuning file with "cfg" suffix */ 150 *filename = kasprintf(GFP_KERNEL, "%scfg", tuning_filename); 151 if (*filename == NULL) 152 return -ENOMEM; 153 154 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev); 155 if (ret != 0) { 156 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename); 157 kfree(*filename); 158 *filename = NULL; 159 } 160 161 return ret; 162 } 163 164 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41, 165 const struct firmware **firmware, char **filename, 166 const char *ssid, const char *amp_name, 167 int spkid, const char *filetype) 168 { 169 const char * const dsp_name = cs35l41->cs_dsp.name; 170 char *s, c; 171 int ret = 0; 172 173 if (spkid > -1 && ssid && amp_name) 174 *filename = kasprintf(GFP_KERNEL, "cirrus/%s-%s-%s-%s-spkid%d-%s.%s", CS35L41_PART, 175 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type], 176 ssid, spkid, amp_name, filetype); 177 else if (spkid > -1 && ssid) 178 *filename = kasprintf(GFP_KERNEL, "cirrus/%s-%s-%s-%s-spkid%d.%s", CS35L41_PART, 179 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type], 180 ssid, spkid, filetype); 181 else if (ssid && amp_name) 182 *filename = kasprintf(GFP_KERNEL, "cirrus/%s-%s-%s-%s-%s.%s", CS35L41_PART, 183 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type], 184 ssid, amp_name, filetype); 185 else if (ssid) 186 *filename = kasprintf(GFP_KERNEL, "cirrus/%s-%s-%s-%s.%s", CS35L41_PART, 187 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type], 188 ssid, filetype); 189 else 190 *filename = kasprintf(GFP_KERNEL, "cirrus/%s-%s-%s.%s", CS35L41_PART, 191 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type], 192 filetype); 193 194 if (*filename == NULL) 195 return -ENOMEM; 196 197 /* 198 * Make sure that filename is lower-case and any non alpha-numeric 199 * characters except full stop and '/' are replaced with hyphens. 200 */ 201 s = *filename; 202 while (*s) { 203 c = *s; 204 if (isalnum(c)) 205 *s = tolower(c); 206 else if (c != '.' && c != '/') 207 *s = '-'; 208 s++; 209 } 210 211 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev); 212 if (ret != 0) { 213 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename); 214 kfree(*filename); 215 *filename = NULL; 216 } 217 218 return ret; 219 } 220 221 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41, 222 const struct firmware **wmfw_firmware, 223 char **wmfw_filename, 224 const struct firmware **coeff_firmware, 225 char **coeff_filename) 226 { 227 int ret; 228 229 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.wmfw */ 230 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 231 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 232 cs35l41->speaker_id, "wmfw"); 233 if (!ret) { 234 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 235 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 236 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 237 cs35l41->speaker_id, "bin"); 238 if (ret) 239 goto coeff_err; 240 241 return 0; 242 } 243 244 /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */ 245 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 246 cs35l41->acpi_subsystem_id, 247 cs35l41->amp_name, -1, "wmfw"); 248 if (!ret) { 249 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 250 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 251 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 252 cs35l41->speaker_id, "bin"); 253 if (ret) 254 goto coeff_err; 255 256 return 0; 257 } 258 259 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */ 260 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 261 cs35l41->acpi_subsystem_id, 262 NULL, cs35l41->speaker_id, "wmfw"); 263 if (!ret) { 264 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 265 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 266 cs35l41->acpi_subsystem_id, 267 cs35l41->amp_name, cs35l41->speaker_id, "bin"); 268 if (ret) 269 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */ 270 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, 271 coeff_filename, 272 cs35l41->acpi_subsystem_id, NULL, 273 cs35l41->speaker_id, "bin"); 274 if (ret) 275 goto coeff_err; 276 277 return 0; 278 } 279 280 /* try cirrus/part-dspN-fwtype-sub.wmfw */ 281 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 282 cs35l41->acpi_subsystem_id, 283 NULL, -1, "wmfw"); 284 if (!ret) { 285 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 286 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 287 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 288 cs35l41->speaker_id, "bin"); 289 if (ret) 290 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */ 291 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, 292 coeff_filename, 293 cs35l41->acpi_subsystem_id, NULL, 294 cs35l41->speaker_id, "bin"); 295 if (ret) 296 goto coeff_err; 297 } 298 299 return ret; 300 coeff_err: 301 release_firmware(*wmfw_firmware); 302 kfree(*wmfw_filename); 303 return ret; 304 } 305 306 static int cs35l41_fallback_firmware_file(struct cs35l41_hda *cs35l41, 307 const struct firmware **wmfw_firmware, 308 char **wmfw_filename, 309 const struct firmware **coeff_firmware, 310 char **coeff_filename) 311 { 312 int ret; 313 314 /* Handle fallback */ 315 dev_warn(cs35l41->dev, "Falling back to default firmware.\n"); 316 317 /* fallback try cirrus/part-dspN-fwtype.wmfw */ 318 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 319 NULL, NULL, -1, "wmfw"); 320 if (ret) 321 goto err; 322 323 /* fallback try cirrus/part-dspN-fwtype.bin */ 324 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 325 NULL, NULL, -1, "bin"); 326 if (ret) { 327 release_firmware(*wmfw_firmware); 328 kfree(*wmfw_filename); 329 goto err; 330 } 331 return 0; 332 333 err: 334 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n"); 335 return ret; 336 } 337 338 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41, 339 const struct firmware **wmfw_firmware, 340 char **wmfw_filename, 341 const struct firmware **coeff_firmware, 342 char **coeff_filename) 343 { 344 int ret; 345 346 if (cs35l41->speaker_id > -1) { 347 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename, 348 coeff_firmware, coeff_filename); 349 goto out; 350 } 351 352 /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */ 353 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 354 cs35l41->acpi_subsystem_id, 355 cs35l41->amp_name, -1, "wmfw"); 356 if (!ret) { 357 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */ 358 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 359 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 360 -1, "bin"); 361 if (ret) 362 goto coeff_err; 363 364 goto out; 365 } 366 367 /* try cirrus/part-dspN-fwtype-sub.wmfw */ 368 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 369 cs35l41->acpi_subsystem_id, 370 NULL, -1, "wmfw"); 371 if (!ret) { 372 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */ 373 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 374 cs35l41->acpi_subsystem_id, 375 cs35l41->amp_name, -1, "bin"); 376 if (ret) 377 /* try cirrus/part-dspN-fwtype-sub.bin */ 378 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 379 cs35l41->acpi_subsystem_id, NULL, -1, 380 "bin"); 381 if (ret) 382 goto coeff_err; 383 } 384 385 out: 386 if (ret) 387 /* if all attempts at finding firmware fail, try fallback */ 388 goto fallback; 389 390 return 0; 391 392 coeff_err: 393 release_firmware(*wmfw_firmware); 394 kfree(*wmfw_filename); 395 fallback: 396 return cs35l41_fallback_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 397 coeff_firmware, coeff_filename); 398 } 399 400 401 static void cs35l41_hda_apply_calibration(struct cs35l41_hda *cs35l41) 402 { 403 int ret; 404 405 if (!cs35l41->cal_data_valid) 406 return; 407 408 ret = cs_amp_write_cal_coeffs(&cs35l41->cs_dsp, &cs35l41_calibration_controls, 409 &cs35l41->cal_data); 410 if (ret < 0) 411 dev_warn(cs35l41->dev, "Failed to apply calibration: %d\n", ret); 412 else 413 dev_info(cs35l41->dev, "Calibration applied: R0=%d\n", cs35l41->cal_data.calR); 414 } 415 416 static int cs35l41_read_silicon_uid(struct cs35l41_hda *cs35l41, u64 *uid) 417 { 418 u32 tmp; 419 int ret; 420 421 ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS2, &tmp); 422 if (ret) { 423 dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS2: %d\n", ret); 424 return ret; 425 } 426 427 *uid = tmp; 428 *uid <<= 32; 429 430 ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS1, &tmp); 431 if (ret) { 432 dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS1: %d\n", ret); 433 return ret; 434 } 435 436 *uid |= tmp; 437 438 dev_dbg(cs35l41->dev, "UniqueID = %#llx\n", *uid); 439 440 return 0; 441 } 442 443 static int cs35l41_get_calibration(struct cs35l41_hda *cs35l41) 444 { 445 u64 silicon_uid; 446 int ret; 447 448 ret = cs35l41_read_silicon_uid(cs35l41, &silicon_uid); 449 if (ret < 0) 450 return ret; 451 452 ret = cs_amp_get_efi_calibration_data(cs35l41->dev, silicon_uid, 453 cs35l41->index, 454 &cs35l41->cal_data); 455 456 /* Only return an error status if probe should be aborted */ 457 if ((ret == -ENOENT) || (ret == -EOVERFLOW)) 458 return 0; 459 460 if (ret < 0) 461 return ret; 462 463 cs35l41->cal_data_valid = true; 464 465 return 0; 466 } 467 468 469 static void cs35l41_set_default_tuning_params(struct cs35l41_hda *cs35l41) 470 { 471 cs35l41->tuning_gain = DEFAULT_AMP_GAIN_PCM; 472 } 473 474 static int cs35l41_read_tuning_params(struct cs35l41_hda *cs35l41, const struct firmware *firmware) 475 { 476 struct cs35l41_tuning_params *params; 477 unsigned int offset = 0; 478 unsigned int end; 479 int i; 480 481 params = (void *)&firmware->data[0]; 482 483 if (le32_to_cpu(params->size) != firmware->size) { 484 dev_err(cs35l41->dev, "Wrong Size for Tuning Param file. Expected %d got %zu\n", 485 le32_to_cpu(params->size), firmware->size); 486 return -EINVAL; 487 } 488 489 if (le32_to_cpu(params->version) != 1) { 490 dev_err(cs35l41->dev, "Unsupported Tuning Param Version: %d\n", 491 le32_to_cpu(params->version)); 492 return -EINVAL; 493 } 494 495 if (le32_to_cpu(params->signature) != CS35L41_TUNING_SIG) { 496 dev_err(cs35l41->dev, 497 "Mismatched Signature for Tuning Param file. Expected %#x got %#x\n", 498 CS35L41_TUNING_SIG, le32_to_cpu(params->signature)); 499 return -EINVAL; 500 } 501 502 end = firmware->size - sizeof(struct cs35l41_tuning_params); 503 504 for (i = 0; i < le32_to_cpu(params->num_entries); i++) { 505 struct cs35l41_tuning_param *param; 506 507 if ((offset >= end) || ((offset + sizeof(struct cs35l41_tuning_param_hdr)) >= end)) 508 return -EFAULT; 509 510 param = (void *)¶ms->data[offset]; 511 offset += le32_to_cpu(param->hdr.size); 512 513 if (offset > end) 514 return -EFAULT; 515 516 switch (le32_to_cpu(param->hdr.type)) { 517 case TUNING_PARAM_GAIN: 518 cs35l41->tuning_gain = le32_to_cpu(param->gain); 519 dev_dbg(cs35l41->dev, "Applying Gain: %d\n", cs35l41->tuning_gain); 520 break; 521 default: 522 break; 523 } 524 } 525 526 return 0; 527 } 528 529 static int cs35l41_load_tuning_params(struct cs35l41_hda *cs35l41, char *tuning_filename) 530 { 531 const struct firmware *tuning_param_file = NULL; 532 char *tuning_param_filename = NULL; 533 int ret; 534 535 ret = cs35l41_request_tuning_param_file(cs35l41, tuning_filename, &tuning_param_file, 536 &tuning_param_filename, cs35l41->acpi_subsystem_id); 537 if (ret) { 538 dev_dbg(cs35l41->dev, "Missing Tuning Param for file: %s: %d\n", tuning_filename, 539 ret); 540 return 0; 541 } 542 543 ret = cs35l41_read_tuning_params(cs35l41, tuning_param_file); 544 if (ret) { 545 dev_err(cs35l41->dev, "Error reading Tuning Params from file: %s: %d\n", 546 tuning_param_filename, ret); 547 /* Reset to default Tuning Parameters */ 548 cs35l41_set_default_tuning_params(cs35l41); 549 } 550 551 release_firmware(tuning_param_file); 552 kfree(tuning_param_filename); 553 554 return ret; 555 } 556 557 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41) 558 { 559 const struct firmware *coeff_firmware = NULL; 560 const struct firmware *wmfw_firmware = NULL; 561 struct cs_dsp *dsp = &cs35l41->cs_dsp; 562 char *coeff_filename = NULL; 563 char *wmfw_filename = NULL; 564 int ret; 565 566 if (!cs35l41->halo_initialized) { 567 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp); 568 dsp->client_ops = &client_ops; 569 570 ret = cs_dsp_halo_init(&cs35l41->cs_dsp); 571 if (ret) 572 return ret; 573 cs35l41->halo_initialized = true; 574 } 575 576 cs35l41_set_default_tuning_params(cs35l41); 577 578 ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename, 579 &coeff_firmware, &coeff_filename); 580 if (ret < 0) 581 return ret; 582 583 dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename); 584 if (coeff_filename) { 585 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename); 586 ret = cs35l41_load_tuning_params(cs35l41, coeff_filename); 587 if (ret) 588 dev_warn(cs35l41->dev, "Unable to load Tuning Parameters: %d\n", ret); 589 } else { 590 dev_warn(cs35l41->dev, "No Coefficient File available.\n"); 591 } 592 593 ret = cs_dsp_power_up(dsp, wmfw_firmware, wmfw_filename, coeff_firmware, coeff_filename, 594 cs35l41_hda_fw_ids[cs35l41->firmware_type]); 595 if (ret) 596 goto err; 597 598 cs35l41_hda_apply_calibration(cs35l41); 599 600 err: 601 if (ret) 602 cs35l41_set_default_tuning_params(cs35l41); 603 release_firmware(wmfw_firmware); 604 release_firmware(coeff_firmware); 605 kfree(wmfw_filename); 606 kfree(coeff_filename); 607 608 return ret; 609 } 610 611 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41) 612 { 613 struct cs_dsp *dsp = &cs35l41->cs_dsp; 614 615 cs35l41_set_default_tuning_params(cs35l41); 616 cs_dsp_stop(dsp); 617 cs_dsp_power_down(dsp); 618 dev_dbg(cs35l41->dev, "Unloaded Firmware\n"); 619 } 620 621 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41) 622 { 623 struct cs_dsp *dsp = &cs35l41->cs_dsp; 624 625 cancel_work_sync(&cs35l41->fw_load_work); 626 627 guard(mutex)(&cs35l41->fw_mutex); 628 cs35l41_shutdown_dsp(cs35l41); 629 cs_dsp_remove(dsp); 630 cs35l41->halo_initialized = false; 631 } 632 633 /* Protection release cycle to get the speaker out of Safe-Mode */ 634 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask) 635 { 636 regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0); 637 regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask); 638 regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask); 639 } 640 641 /* Clear all errors to release safe mode. Global Enable must be cleared first. */ 642 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41) 643 { 644 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors); 645 cs35l41->irq_errors = 0; 646 } 647 648 static void cs35l41_update_mixer(struct cs35l41_hda *cs35l41) 649 { 650 struct regmap *reg = cs35l41->regmap; 651 unsigned int asp_en = 0; 652 unsigned int dsp1rx2_src = 0; 653 654 regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config)); 655 656 if (cs35l41->cs_dsp.running) { 657 asp_en |= CS35L41_ASP_TX1_EN_MASK; // ASP_TX1_EN = 1 658 regmap_multi_reg_write(reg, cs35l41_hda_config_dsp, 659 ARRAY_SIZE(cs35l41_hda_config_dsp)); 660 if (cs35l41->hw_cfg.bst_type == CS35L41_INT_BOOST) 661 regmap_write(reg, CS35L41_DSP1_RX5_SRC, CS35L41_INPUT_SRC_VPMON); 662 else 663 regmap_write(reg, CS35L41_DSP1_RX5_SRC, CS35L41_INPUT_SRC_VBSTMON); 664 } else { 665 regmap_multi_reg_write(reg, cs35l41_hda_config_no_dsp, 666 ARRAY_SIZE(cs35l41_hda_config_no_dsp)); 667 } 668 669 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER) { 670 asp_en |= CS35L41_ASP_RX2_EN_MASK; // ASP_RX2_EN = 1 671 dsp1rx2_src = 0x00000009; // DSP1RX2 SRC = ASPRX2 672 } else { 673 dsp1rx2_src = 0x00000008; // DSP1RX2 SRC = ASPRX1 674 } 675 676 asp_en |= CS35L41_ASP_RX1_EN_MASK; // ASP_RX1_EN = 1 677 678 regmap_write(reg, CS35L41_SP_ENABLES, asp_en); 679 regmap_write(reg, CS35L41_DSP1_RX1_SRC, 0x00000008); // DSP1RX1 SRC = ASPRX1 680 regmap_write(reg, CS35L41_DSP1_RX2_SRC, dsp1rx2_src); 681 } 682 683 static void cs35l41_hda_play_start(struct device *dev) 684 { 685 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 686 struct regmap *reg = cs35l41->regmap; 687 688 dev_dbg(dev, "Play (Start)\n"); 689 690 if (cs35l41->playback_started) { 691 dev_dbg(dev, "Playback already started."); 692 return; 693 } 694 695 cs35l41->playback_started = true; 696 697 cs35l41_update_mixer(cs35l41); 698 699 if (cs35l41->cs_dsp.running) { 700 regmap_update_bits(reg, CS35L41_PWR_CTRL2, 701 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 702 1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT); 703 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME); 704 } 705 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT); 706 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 707 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001); 708 709 } 710 711 static void cs35l41_mute(struct device *dev, bool mute) 712 { 713 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 714 struct regmap *reg = cs35l41->regmap; 715 unsigned int amp_gain; 716 717 dev_dbg(dev, "Mute(%d:%d) Playback Started: %d\n", mute, cs35l41->mute_override, 718 cs35l41->playback_started); 719 720 if (cs35l41->playback_started) { 721 if (mute || cs35l41->mute_override) { 722 dev_dbg(dev, "Muting\n"); 723 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute)); 724 } else { 725 dev_dbg(dev, "Unmuting\n"); 726 if (cs35l41->cs_dsp.running) { 727 dev_dbg(dev, "Using Tuned Gain: %d\n", cs35l41->tuning_gain); 728 amp_gain = (cs35l41->tuning_gain << CS35L41_AMP_GAIN_PCM_SHIFT) | 729 (DEFAULT_AMP_GAIN_PDM << CS35L41_AMP_GAIN_PDM_SHIFT); 730 731 /* AMP_HPF_PCM_EN = 1, AMP_VOL_PCM 0.0 dB */ 732 regmap_write(reg, CS35L41_AMP_DIG_VOL_CTRL, 0x00008000); 733 regmap_write(reg, CS35L41_AMP_GAIN_CTRL, amp_gain); 734 } else { 735 regmap_multi_reg_write(reg, cs35l41_hda_unmute, 736 ARRAY_SIZE(cs35l41_hda_unmute)); 737 } 738 } 739 } 740 } 741 742 static void cs35l41_hda_play_done(struct device *dev) 743 { 744 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 745 struct regmap *reg = cs35l41->regmap; 746 747 dev_dbg(dev, "Play (Complete)\n"); 748 749 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, 750 &cs35l41->cs_dsp); 751 cs35l41_mute(dev, false); 752 } 753 754 static void cs35l41_hda_pause_start(struct device *dev) 755 { 756 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 757 struct regmap *reg = cs35l41->regmap; 758 759 dev_dbg(dev, "Pause (Start)\n"); 760 761 cs35l41_mute(dev, true); 762 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, 763 &cs35l41->cs_dsp); 764 } 765 766 static void cs35l41_hda_pause_done(struct device *dev) 767 { 768 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 769 struct regmap *reg = cs35l41->regmap; 770 771 dev_dbg(dev, "Pause (Complete)\n"); 772 773 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT); 774 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 775 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001); 776 if (cs35l41->cs_dsp.running) { 777 cs35l41_set_cspl_mbox_cmd(dev, reg, CSPL_MBOX_CMD_PAUSE); 778 regmap_update_bits(reg, CS35L41_PWR_CTRL2, 779 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 780 0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT); 781 } 782 cs35l41_irq_release(cs35l41); 783 cs35l41->playback_started = false; 784 } 785 786 static void cs35l41_hda_pre_playback_hook(struct device *dev, int action) 787 { 788 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 789 790 switch (action) { 791 case HDA_GEN_PCM_ACT_CLEANUP: 792 scoped_guard(mutex, &cs35l41->fw_mutex) { 793 cs35l41_hda_pause_start(dev); 794 } 795 break; 796 default: 797 break; 798 } 799 } 800 static void cs35l41_hda_playback_hook(struct device *dev, int action) 801 { 802 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 803 804 switch (action) { 805 case HDA_GEN_PCM_ACT_OPEN: 806 /* 807 * All amps must be resumed before we can start playing back. 808 * This ensures, for external boost, that all amps are in AMP_SAFE mode. 809 * Do this in HDA_GEN_PCM_ACT_OPEN, since this is run prior to any of the 810 * other actions. 811 */ 812 pm_runtime_get_sync(dev); 813 break; 814 case HDA_GEN_PCM_ACT_PREPARE: 815 scoped_guard(mutex, &cs35l41->fw_mutex) { 816 cs35l41_hda_play_start(dev); 817 } 818 break; 819 case HDA_GEN_PCM_ACT_CLEANUP: 820 scoped_guard(mutex, &cs35l41->fw_mutex) { 821 cs35l41_hda_pause_done(dev); 822 } 823 break; 824 case HDA_GEN_PCM_ACT_CLOSE: 825 scoped_guard(mutex, &cs35l41->fw_mutex) { 826 if (!cs35l41->cs_dsp.running && cs35l41->request_fw_load && 827 !cs35l41->fw_request_ongoing) { 828 dev_info(dev, "Requesting Firmware Load after HDA_GEN_PCM_ACT_CLOSE\n"); 829 cs35l41->fw_request_ongoing = true; 830 schedule_work(&cs35l41->fw_load_work); 831 } 832 } 833 834 /* 835 * Playback must be finished for all amps before we start runtime suspend. 836 * This ensures no amps are playing back when we start putting them to sleep. 837 */ 838 pm_runtime_put_autosuspend(dev); 839 break; 840 default: 841 break; 842 } 843 } 844 845 static void cs35l41_hda_post_playback_hook(struct device *dev, int action) 846 { 847 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 848 849 switch (action) { 850 case HDA_GEN_PCM_ACT_PREPARE: 851 scoped_guard(mutex, &cs35l41->fw_mutex) { 852 cs35l41_hda_play_done(dev); 853 } 854 break; 855 default: 856 break; 857 } 858 } 859 860 static int cs35l41_hda_channel_map(struct cs35l41_hda *cs35l41) 861 { 862 unsigned int tx_num = 0; 863 unsigned int *tx_slot = NULL; 864 unsigned int rx_num; 865 unsigned int *rx_slot; 866 unsigned int mono = 0; 867 868 if (!cs35l41->amp_name) { 869 if (cs35l41->hw_cfg.spk_pos >= ARRAY_SIZE(channel_name)) 870 return -EINVAL; 871 872 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%c%d", 873 channel_name[cs35l41->hw_cfg.spk_pos], 874 cs35l41->channel_index); 875 if (!cs35l41->amp_name) 876 return -ENOMEM; 877 } 878 879 rx_num = 1; 880 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER) 881 rx_slot = &mono; 882 else 883 rx_slot = &cs35l41->hw_cfg.spk_pos; 884 885 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num, 886 rx_slot); 887 } 888 889 static int cs35l41_verify_id(struct cs35l41_hda *cs35l41, unsigned int *regid, unsigned int *reg_revid) 890 { 891 unsigned int mtl_revid, chipid; 892 int ret; 893 894 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, regid); 895 if (ret) { 896 dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n"); 897 return ret; 898 } 899 900 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, reg_revid); 901 if (ret) { 902 dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n"); 903 return ret; 904 } 905 906 mtl_revid = *reg_revid & CS35L41_MTLREVID_MASK; 907 908 chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID; 909 if (*regid != chipid) { 910 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", *regid, chipid); 911 return -ENODEV; 912 } 913 914 return 0; 915 } 916 917 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41) 918 { 919 guard(mutex)(&cs35l41->fw_mutex); 920 if (cs35l41->cs_dsp.running) { 921 cs35l41->cs_dsp.running = false; 922 cs35l41->cs_dsp.booted = false; 923 } 924 regcache_mark_dirty(cs35l41->regmap); 925 926 return 0; 927 } 928 929 static int cs35l41_system_suspend_prep(struct device *dev) 930 { 931 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 932 933 dev_dbg(cs35l41->dev, "System Suspend Prepare\n"); 934 935 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 936 dev_err_once(cs35l41->dev, "System Suspend not supported\n"); 937 return 0; /* don't block the whole system suspend */ 938 } 939 940 guard(mutex)(&cs35l41->fw_mutex); 941 if (cs35l41->playback_started) 942 cs35l41_hda_pause_start(dev); 943 944 return 0; 945 } 946 947 static int cs35l41_system_suspend(struct device *dev) 948 { 949 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 950 int ret; 951 952 dev_dbg(cs35l41->dev, "System Suspend\n"); 953 954 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 955 dev_err_once(cs35l41->dev, "System Suspend not supported\n"); 956 return 0; /* don't block the whole system suspend */ 957 } 958 959 scoped_guard(mutex, &cs35l41->fw_mutex) { 960 if (cs35l41->playback_started) 961 cs35l41_hda_pause_done(dev); 962 } 963 964 ret = pm_runtime_force_suspend(dev); 965 if (ret) { 966 dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret); 967 return ret; 968 } 969 970 /* Shutdown DSP before system suspend */ 971 ret = cs35l41_ready_for_reset(cs35l41); 972 if (ret) 973 dev_err(dev, "System Suspend Failed, not ready for Reset: %d\n", ret); 974 975 if (cs35l41->reset_gpio) { 976 dev_info(cs35l41->dev, "Asserting Reset\n"); 977 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 978 usleep_range(2000, 2100); 979 } 980 981 dev_dbg(cs35l41->dev, "System Suspended\n"); 982 983 return ret; 984 } 985 986 static int cs35l41_wait_boot_done(struct cs35l41_hda *cs35l41) 987 { 988 unsigned int int_status; 989 int ret; 990 991 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status, 992 int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000); 993 if (ret) { 994 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE\n"); 995 return ret; 996 } 997 998 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_status); 999 if (ret || (int_status & CS35L41_OTP_BOOT_ERR)) { 1000 dev_err(cs35l41->dev, "OTP Boot status %x error\n", 1001 int_status & CS35L41_OTP_BOOT_ERR); 1002 if (!ret) 1003 ret = -EIO; 1004 return ret; 1005 } 1006 1007 return 0; 1008 } 1009 1010 static int cs35l41_system_resume(struct device *dev) 1011 { 1012 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1013 int ret; 1014 1015 dev_dbg(cs35l41->dev, "System Resume\n"); 1016 1017 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 1018 dev_err_once(cs35l41->dev, "System Resume not supported\n"); 1019 return 0; /* don't block the whole system resume */ 1020 } 1021 1022 if (cs35l41->reset_gpio) { 1023 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 1024 usleep_range(2000, 2100); 1025 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 1026 } 1027 1028 usleep_range(2000, 2100); 1029 1030 regcache_cache_only(cs35l41->regmap, false); 1031 1032 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET); 1033 usleep_range(2000, 2100); 1034 1035 ret = cs35l41_wait_boot_done(cs35l41); 1036 if (ret) 1037 return ret; 1038 1039 regcache_cache_only(cs35l41->regmap, true); 1040 1041 ret = pm_runtime_force_resume(dev); 1042 if (ret) { 1043 dev_err(dev, "System Resume Failed: Unable to runtime resume: %d\n", ret); 1044 return ret; 1045 } 1046 1047 guard(mutex)(&cs35l41->fw_mutex); 1048 1049 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) { 1050 cs35l41->fw_request_ongoing = true; 1051 schedule_work(&cs35l41->fw_load_work); 1052 } 1053 1054 return ret; 1055 } 1056 1057 static int cs35l41_runtime_idle(struct device *dev) 1058 { 1059 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1060 1061 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) 1062 return -EBUSY; /* suspend not supported yet on this model */ 1063 return 0; 1064 } 1065 1066 static int cs35l41_runtime_suspend(struct device *dev) 1067 { 1068 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1069 int ret; 1070 1071 dev_dbg(cs35l41->dev, "Runtime Suspend\n"); 1072 1073 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 1074 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n"); 1075 return 0; 1076 } 1077 1078 guard(mutex)(&cs35l41->fw_mutex); 1079 1080 if (cs35l41->cs_dsp.running) { 1081 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap, 1082 cs35l41->hw_cfg.bst_type); 1083 if (ret) 1084 return ret; 1085 } else { 1086 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type); 1087 } 1088 1089 regcache_cache_only(cs35l41->regmap, true); 1090 regcache_mark_dirty(cs35l41->regmap); 1091 1092 return 0; 1093 } 1094 1095 static int cs35l41_runtime_resume(struct device *dev) 1096 { 1097 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1098 unsigned int regid, reg_revid; 1099 int ret; 1100 1101 dev_dbg(cs35l41->dev, "Runtime Resume\n"); 1102 1103 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 1104 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n"); 1105 return 0; 1106 } 1107 1108 guard(mutex)(&cs35l41->fw_mutex); 1109 1110 regcache_cache_only(cs35l41->regmap, false); 1111 1112 if (cs35l41->cs_dsp.running) { 1113 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap); 1114 if (ret) { 1115 dev_warn(cs35l41->dev, "Unable to exit Hibernate."); 1116 return ret; 1117 } 1118 } 1119 1120 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid); 1121 if (ret) 1122 return ret; 1123 1124 /* Test key needs to be unlocked to allow the OTP settings to re-apply */ 1125 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 1126 ret = regcache_sync(cs35l41->regmap); 1127 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 1128 if (ret) { 1129 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret); 1130 return ret; 1131 } 1132 1133 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 1134 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg); 1135 1136 dev_dbg(cs35l41->dev, "CS35L41 Resumed (%x), Revision: %02X\n", regid, reg_revid); 1137 1138 return 0; 1139 } 1140 1141 static int cs35l41_hda_read_ctl(struct cs_dsp *dsp, const char *name, int type, 1142 unsigned int alg, void *buf, size_t len) 1143 { 1144 guard(mutex)(&dsp->pwr_lock); 1145 return cs_dsp_coeff_read_ctrl(cs_dsp_get_ctl(dsp, name, type, alg), 0, buf, len); 1146 } 1147 1148 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41) 1149 { 1150 unsigned int fw_status; 1151 __be32 halo_sts; 1152 int ret; 1153 1154 if (cs35l41->bypass_fw) { 1155 dev_warn(cs35l41->dev, "Bypassing Firmware.\n"); 1156 return 0; 1157 } 1158 1159 ret = cs35l41_init_dsp(cs35l41); 1160 if (ret) { 1161 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret); 1162 goto clean_dsp; 1163 } 1164 1165 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap); 1166 if (ret) { 1167 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret); 1168 goto clean_dsp; 1169 } 1170 1171 ret = cs_dsp_run(&cs35l41->cs_dsp); 1172 if (ret) { 1173 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret); 1174 goto clean_dsp; 1175 } 1176 1177 ret = read_poll_timeout(cs35l41_hda_read_ctl, ret, 1178 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN, 1179 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME, 1180 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG, 1181 &halo_sts, sizeof(halo_sts)); 1182 1183 if (ret) { 1184 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n", 1185 halo_sts); 1186 goto clean_dsp; 1187 } 1188 1189 ret = regmap_read(cs35l41->regmap, CS35L41_DSP_MBOX_2, &fw_status); 1190 if (ret < 0) { 1191 dev_err(cs35l41->dev, 1192 "Failed to read firmware status: %d\n", ret); 1193 goto clean_dsp; 1194 } 1195 1196 switch (fw_status) { 1197 case CSPL_MBOX_STS_RUNNING: 1198 case CSPL_MBOX_STS_PAUSED: 1199 break; 1200 default: 1201 dev_err(cs35l41->dev, "Firmware status is invalid: %u\n", 1202 fw_status); 1203 ret = -EINVAL; 1204 goto clean_dsp; 1205 } 1206 1207 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE); 1208 if (ret) { 1209 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret); 1210 goto clean_dsp; 1211 } 1212 1213 dev_info(cs35l41->dev, "Firmware Loaded - Type: %s, Gain: %d\n", 1214 cs35l41_hda_fw_ids[cs35l41->firmware_type], cs35l41->tuning_gain); 1215 1216 return 0; 1217 1218 clean_dsp: 1219 cs35l41_shutdown_dsp(cs35l41); 1220 return ret; 1221 } 1222 1223 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load) 1224 { 1225 if (cs35l41->cs_dsp.running && !load) { 1226 dev_dbg(cs35l41->dev, "Unloading Firmware\n"); 1227 cs35l41_shutdown_dsp(cs35l41); 1228 } else if (!cs35l41->cs_dsp.running && load) { 1229 dev_dbg(cs35l41->dev, "Loading Firmware\n"); 1230 cs35l41_smart_amp(cs35l41); 1231 } else { 1232 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n"); 1233 } 1234 } 1235 1236 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol, 1237 struct snd_ctl_elem_value *ucontrol) 1238 { 1239 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1240 1241 ucontrol->value.integer.value[0] = cs35l41->request_fw_load; 1242 return 0; 1243 } 1244 1245 static int cs35l41_mute_override_ctl_get(struct snd_kcontrol *kcontrol, 1246 struct snd_ctl_elem_value *ucontrol) 1247 { 1248 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1249 1250 ucontrol->value.integer.value[0] = cs35l41->mute_override; 1251 return 0; 1252 } 1253 1254 static void cs35l41_fw_load_work(struct work_struct *work) 1255 { 1256 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work); 1257 1258 guard(pm_runtime_active_auto)(cs35l41->dev); 1259 1260 guard(mutex)(&cs35l41->fw_mutex); 1261 /* Recheck if playback is ongoing, mutex will block playback during firmware loading */ 1262 if (cs35l41->playback_started) 1263 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n"); 1264 else 1265 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load); 1266 1267 cs35l41->fw_request_ongoing = false; 1268 } 1269 1270 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol, 1271 struct snd_ctl_elem_value *ucontrol) 1272 { 1273 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1274 1275 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0]) 1276 return 0; 1277 1278 if (cs35l41->fw_request_ongoing) { 1279 dev_dbg(cs35l41->dev, "Existing request not complete\n"); 1280 return -EBUSY; 1281 } 1282 1283 /* Check if playback is ongoing when initial request is made */ 1284 if (cs35l41->playback_started) { 1285 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n"); 1286 return -EBUSY; 1287 } 1288 1289 cs35l41->fw_request_ongoing = true; 1290 cs35l41->request_fw_load = ucontrol->value.integer.value[0]; 1291 schedule_work(&cs35l41->fw_load_work); 1292 1293 return 1; 1294 } 1295 1296 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol, 1297 struct snd_ctl_elem_value *ucontrol) 1298 { 1299 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1300 1301 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type; 1302 1303 return 0; 1304 } 1305 1306 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol, 1307 struct snd_ctl_elem_value *ucontrol) 1308 { 1309 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1310 1311 if (ucontrol->value.enumerated.item[0] < CS35L41_HDA_NUM_FW) { 1312 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) { 1313 cs35l41->firmware_type = ucontrol->value.enumerated.item[0]; 1314 return 1; 1315 } else { 1316 return 0; 1317 } 1318 } 1319 1320 return -EINVAL; 1321 } 1322 1323 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1324 { 1325 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(cs35l41_hda_fw_ids), cs35l41_hda_fw_ids); 1326 } 1327 1328 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41) 1329 { 1330 char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1331 char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1332 char mute_override_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1333 struct snd_kcontrol_new fw_type_ctl = { 1334 .name = fw_type_ctl_name, 1335 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1336 .info = cs35l41_fw_type_ctl_info, 1337 .get = cs35l41_fw_type_ctl_get, 1338 .put = cs35l41_fw_type_ctl_put, 1339 }; 1340 struct snd_kcontrol_new fw_load_ctl = { 1341 .name = fw_load_ctl_name, 1342 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1343 .info = snd_ctl_boolean_mono_info, 1344 .get = cs35l41_fw_load_ctl_get, 1345 .put = cs35l41_fw_load_ctl_put, 1346 }; 1347 struct snd_kcontrol_new mute_override_ctl = { 1348 .name = mute_override_ctl_name, 1349 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1350 .info = snd_ctl_boolean_mono_info, 1351 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1352 .get = cs35l41_mute_override_ctl_get, 1353 }; 1354 int ret; 1355 1356 scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type", 1357 cs35l41->amp_name); 1358 scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load", 1359 cs35l41->amp_name); 1360 scnprintf(mute_override_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s Forced Mute Status", 1361 cs35l41->amp_name); 1362 1363 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41)); 1364 if (ret) { 1365 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret); 1366 return ret; 1367 } 1368 1369 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name); 1370 1371 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41)); 1372 if (ret) { 1373 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret); 1374 return ret; 1375 } 1376 1377 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name); 1378 1379 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&mute_override_ctl, cs35l41)); 1380 if (ret) { 1381 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", mute_override_ctl.name, 1382 ret); 1383 return ret; 1384 } 1385 1386 dev_dbg(cs35l41->dev, "Added Control %s\n", mute_override_ctl.name); 1387 1388 return 0; 1389 } 1390 1391 static bool cs35l41_dsm_supported(acpi_handle handle, unsigned int commands) 1392 { 1393 guid_t guid; 1394 1395 guid_parse(CS35L41_UUID, &guid); 1396 1397 return acpi_check_dsm(handle, &guid, 0, BIT(commands)); 1398 } 1399 1400 static int cs35l41_get_acpi_mute_state(struct cs35l41_hda *cs35l41, acpi_handle handle) 1401 { 1402 guid_t guid; 1403 union acpi_object *ret; 1404 int mute = -ENODEV; 1405 1406 guid_parse(CS35L41_UUID, &guid); 1407 1408 if (cs35l41_dsm_supported(handle, CS35L41_DSM_GET_MUTE)) { 1409 ret = acpi_evaluate_dsm(handle, &guid, 0, CS35L41_DSM_GET_MUTE, NULL); 1410 if (!ret) 1411 return -EINVAL; 1412 mute = *ret->buffer.pointer; 1413 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute); 1414 } 1415 1416 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute); 1417 1418 return mute; 1419 } 1420 1421 static void cs35l41_acpi_device_notify(acpi_handle handle, u32 event, struct device *dev) 1422 { 1423 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1424 int mute; 1425 1426 if (event != CS35L41_NOTIFY_EVENT) 1427 return; 1428 1429 mute = cs35l41_get_acpi_mute_state(cs35l41, handle); 1430 if (mute < 0) { 1431 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute); 1432 return; 1433 } 1434 1435 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute); 1436 cs35l41->mute_override = (mute > 0); 1437 cs35l41_mute(cs35l41->dev, cs35l41->mute_override); 1438 } 1439 1440 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data) 1441 { 1442 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1443 struct hda_component_parent *parent = master_data; 1444 struct hda_component *comp; 1445 unsigned int sleep_flags; 1446 int ret = 0; 1447 1448 comp = hda_component_from_index(parent, cs35l41->index); 1449 if (!comp) 1450 return -EINVAL; 1451 1452 if (comp->dev) 1453 return -EBUSY; 1454 1455 guard(pm_runtime_active_auto)(dev); 1456 1457 mutex_lock(&cs35l41->fw_mutex); 1458 1459 comp->dev = dev; 1460 cs35l41->codec = parent->codec; 1461 if (!cs35l41->acpi_subsystem_id) 1462 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x", 1463 cs35l41->codec->core.subsystem_id); 1464 1465 strscpy(comp->name, dev_name(dev), sizeof(comp->name)); 1466 1467 cs35l41->firmware_type = CS35L41_HDA_FW_SPK_PROT; 1468 1469 if (firmware_autostart) { 1470 dev_dbg(cs35l41->dev, "Firmware Autostart.\n"); 1471 cs35l41->request_fw_load = true; 1472 if (cs35l41_smart_amp(cs35l41) < 0) 1473 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n"); 1474 } else { 1475 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n"); 1476 } 1477 1478 ret = cs35l41_create_controls(cs35l41); 1479 1480 comp->playback_hook = cs35l41_hda_playback_hook; 1481 comp->pre_playback_hook = cs35l41_hda_pre_playback_hook; 1482 comp->post_playback_hook = cs35l41_hda_post_playback_hook; 1483 comp->acpi_notify = cs35l41_acpi_device_notify; 1484 comp->adev = cs35l41->dacpi; 1485 1486 comp->acpi_notifications_supported = cs35l41_dsm_supported(acpi_device_handle(comp->adev), 1487 CS35L41_DSM_GET_MUTE); 1488 1489 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41, 1490 acpi_device_handle(cs35l41->dacpi)) > 0; 1491 1492 mutex_unlock(&cs35l41->fw_mutex); 1493 1494 sleep_flags = lock_system_sleep(); 1495 if (!device_link_add(&cs35l41->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS)) 1496 dev_warn(dev, "Unable to create device link\n"); 1497 unlock_system_sleep(sleep_flags); 1498 1499 dev_info(cs35l41->dev, 1500 "CS35L41 Bound - SSID: %s, BST: %d, VSPK: %d, CH: %c, FW EN: %d, SPKID: %d\n", 1501 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type, 1502 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH, 1503 channel_name[cs35l41->hw_cfg.spk_pos], 1504 cs35l41->cs_dsp.running, cs35l41->speaker_id); 1505 1506 return ret; 1507 } 1508 1509 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data) 1510 { 1511 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1512 struct hda_component_parent *parent = master_data; 1513 struct hda_component *comp; 1514 unsigned int sleep_flags; 1515 1516 comp = hda_component_from_index(parent, cs35l41->index); 1517 if (!comp) 1518 return; 1519 1520 if (comp->dev == dev) { 1521 sleep_flags = lock_system_sleep(); 1522 device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev); 1523 unlock_system_sleep(sleep_flags); 1524 memset(comp, 0, sizeof(*comp)); 1525 } 1526 } 1527 1528 static const struct component_ops cs35l41_hda_comp_ops = { 1529 .bind = cs35l41_hda_bind, 1530 .unbind = cs35l41_hda_unbind, 1531 }; 1532 1533 static irqreturn_t cs35l41_bst_short_err(int irq, void *data) 1534 { 1535 struct cs35l41_hda *cs35l41 = data; 1536 1537 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n"); 1538 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1539 1540 return IRQ_HANDLED; 1541 } 1542 1543 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data) 1544 { 1545 struct cs35l41_hda *cs35l41 = data; 1546 1547 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n"); 1548 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1549 1550 return IRQ_HANDLED; 1551 } 1552 1553 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data) 1554 { 1555 struct cs35l41_hda *cs35l41 = data; 1556 1557 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n"); 1558 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1559 1560 return IRQ_HANDLED; 1561 } 1562 1563 static irqreturn_t cs35l41_temp_err(int irq, void *data) 1564 { 1565 struct cs35l41_hda *cs35l41 = data; 1566 1567 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n"); 1568 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1569 1570 return IRQ_HANDLED; 1571 } 1572 1573 static irqreturn_t cs35l41_temp_warn(int irq, void *data) 1574 { 1575 struct cs35l41_hda *cs35l41 = data; 1576 1577 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n"); 1578 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1579 1580 return IRQ_HANDLED; 1581 } 1582 1583 static irqreturn_t cs35l41_amp_short(int irq, void *data) 1584 { 1585 struct cs35l41_hda *cs35l41 = data; 1586 1587 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n"); 1588 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1589 1590 return IRQ_HANDLED; 1591 } 1592 1593 static const struct cs35l41_irq cs35l41_irqs[] = { 1594 CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err), 1595 CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err), 1596 CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err), 1597 CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn), 1598 CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err), 1599 CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short), 1600 }; 1601 1602 static const struct regmap_irq cs35l41_reg_irqs[] = { 1603 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR), 1604 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR), 1605 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR), 1606 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN), 1607 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR), 1608 CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR), 1609 }; 1610 1611 static const struct regmap_irq_chip cs35l41_regmap_irq_chip = { 1612 .name = "cs35l41 IRQ1 Controller", 1613 .status_base = CS35L41_IRQ1_STATUS1, 1614 .mask_base = CS35L41_IRQ1_MASK1, 1615 .ack_base = CS35L41_IRQ1_STATUS1, 1616 .num_regs = 4, 1617 .irqs = cs35l41_reg_irqs, 1618 .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs), 1619 .runtime_pm = true, 1620 }; 1621 1622 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol) 1623 { 1624 int irq; 1625 int ret; 1626 int i; 1627 1628 if (!cs35l41->irq) { 1629 dev_warn(cs35l41->dev, "No Interrupt Found"); 1630 goto err; 1631 } 1632 1633 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq, 1634 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1635 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data); 1636 if (ret) { 1637 dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret); 1638 goto err; 1639 } 1640 1641 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) { 1642 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq); 1643 if (irq < 0) { 1644 ret = irq; 1645 dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name, 1646 ret); 1647 goto err; 1648 } 1649 1650 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL, 1651 cs35l41_irqs[i].handler, 1652 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1653 cs35l41_irqs[i].name, cs35l41); 1654 if (ret) { 1655 dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.", 1656 cs35l41_irqs[i].name, ret); 1657 goto err; 1658 } 1659 } 1660 return; 1661 err: 1662 dev_warn(cs35l41->dev, 1663 "IRQ Config Failed. Amp errors may not be recoverable without reboot."); 1664 } 1665 1666 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41) 1667 { 1668 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1669 bool using_irq = false; 1670 int irq_pol; 1671 int ret; 1672 1673 if (!cs35l41->hw_cfg.valid) 1674 return -EINVAL; 1675 1676 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg); 1677 if (ret) 1678 return ret; 1679 1680 if (hw_cfg->gpio1.valid) { 1681 switch (hw_cfg->gpio1.func) { 1682 case CS35L41_NOT_USED: 1683 break; 1684 case CS35l41_VSPK_SWITCH: 1685 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO; 1686 hw_cfg->gpio1.out_en = true; 1687 break; 1688 case CS35l41_SYNC: 1689 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC; 1690 break; 1691 default: 1692 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n", 1693 hw_cfg->gpio1.func); 1694 return -EINVAL; 1695 } 1696 } 1697 1698 if (hw_cfg->gpio2.valid) { 1699 switch (hw_cfg->gpio2.func) { 1700 case CS35L41_NOT_USED: 1701 break; 1702 case CS35L41_INTERRUPT: 1703 using_irq = true; 1704 hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN; 1705 break; 1706 default: 1707 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func); 1708 return -EINVAL; 1709 } 1710 } 1711 1712 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg); 1713 1714 if (using_irq) 1715 cs35l41_configure_interrupt(cs35l41, irq_pol); 1716 1717 return cs35l41_hda_channel_map(cs35l41); 1718 } 1719 1720 int cs35l41_get_speaker_id(struct device *dev, int amp_index, int num_amps, int fixed_gpio_id) 1721 { 1722 struct gpio_desc *speaker_id_desc; 1723 int speaker_id = -ENODEV; 1724 1725 if (fixed_gpio_id >= 0) { 1726 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id); 1727 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN); 1728 if (IS_ERR(speaker_id_desc)) { 1729 speaker_id = PTR_ERR(speaker_id_desc); 1730 return speaker_id; 1731 } 1732 speaker_id = gpiod_get_value_cansleep(speaker_id_desc); 1733 gpiod_put(speaker_id_desc); 1734 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1735 } else { 1736 int base_index; 1737 int gpios_per_amp; 1738 int count; 1739 int tmp; 1740 int i; 1741 1742 count = gpiod_count(dev, "spk-id"); 1743 if (count > 0) { 1744 speaker_id = 0; 1745 gpios_per_amp = count / num_amps; 1746 base_index = gpios_per_amp * amp_index; 1747 1748 if (count % num_amps) 1749 return -EINVAL; 1750 1751 dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp); 1752 1753 for (i = 0; i < gpios_per_amp; i++) { 1754 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index, 1755 GPIOD_IN); 1756 if (IS_ERR(speaker_id_desc)) { 1757 speaker_id = PTR_ERR(speaker_id_desc); 1758 break; 1759 } 1760 tmp = gpiod_get_value_cansleep(speaker_id_desc); 1761 gpiod_put(speaker_id_desc); 1762 if (tmp < 0) { 1763 speaker_id = tmp; 1764 break; 1765 } 1766 speaker_id |= tmp << i; 1767 } 1768 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1769 } 1770 } 1771 return speaker_id; 1772 } 1773 1774 int cs35l41_hda_parse_acpi(struct cs35l41_hda *cs35l41, struct device *physdev, int id) 1775 { 1776 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1777 u32 values[HDA_MAX_COMPONENTS]; 1778 char *property; 1779 size_t nval; 1780 int i, ret; 1781 1782 property = "cirrus,dev-index"; 1783 ret = device_property_count_u32(physdev, property); 1784 if (ret <= 0) 1785 goto err; 1786 1787 if (ret > ARRAY_SIZE(values)) { 1788 ret = -EINVAL; 1789 goto err; 1790 } 1791 nval = ret; 1792 1793 ret = device_property_read_u32_array(physdev, property, values, nval); 1794 if (ret) 1795 goto err; 1796 1797 cs35l41->index = -1; 1798 for (i = 0; i < nval; i++) { 1799 if (values[i] == id) { 1800 cs35l41->index = i; 1801 break; 1802 } 1803 } 1804 if (cs35l41->index == -1) { 1805 dev_err(cs35l41->dev, "No index found in %s\n", property); 1806 ret = -ENODEV; 1807 goto err; 1808 } 1809 1810 /* To use the same release code for all laptop variants we can't use devm_ version of 1811 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node 1812 */ 1813 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(cs35l41->dacpi), "reset", 1814 cs35l41->index, GPIOD_OUT_LOW, 1815 "cs35l41-reset"); 1816 1817 property = "cirrus,speaker-position"; 1818 ret = device_property_read_u32_array(physdev, property, values, nval); 1819 if (ret) 1820 goto err; 1821 hw_cfg->spk_pos = values[cs35l41->index]; 1822 1823 cs35l41->channel_index = 0; 1824 for (i = 0; i < cs35l41->index; i++) 1825 if (values[i] == hw_cfg->spk_pos) 1826 cs35l41->channel_index++; 1827 1828 property = "cirrus,gpio1-func"; 1829 ret = device_property_read_u32_array(physdev, property, values, nval); 1830 if (ret) 1831 goto err; 1832 hw_cfg->gpio1.func = values[cs35l41->index]; 1833 hw_cfg->gpio1.valid = true; 1834 1835 property = "cirrus,gpio2-func"; 1836 ret = device_property_read_u32_array(physdev, property, values, nval); 1837 if (ret) 1838 goto err; 1839 hw_cfg->gpio2.func = values[cs35l41->index]; 1840 hw_cfg->gpio2.valid = true; 1841 1842 property = "cirrus,boost-peak-milliamp"; 1843 ret = device_property_read_u32_array(physdev, property, values, nval); 1844 if (ret == 0) 1845 hw_cfg->bst_ipk = values[cs35l41->index]; 1846 else 1847 hw_cfg->bst_ipk = -1; 1848 1849 property = "cirrus,boost-ind-nanohenry"; 1850 ret = device_property_read_u32_array(physdev, property, values, nval); 1851 if (ret == 0) 1852 hw_cfg->bst_ind = values[cs35l41->index]; 1853 else 1854 hw_cfg->bst_ind = -1; 1855 1856 property = "cirrus,boost-cap-microfarad"; 1857 ret = device_property_read_u32_array(physdev, property, values, nval); 1858 if (ret == 0) 1859 hw_cfg->bst_cap = values[cs35l41->index]; 1860 else 1861 hw_cfg->bst_cap = -1; 1862 1863 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1); 1864 1865 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0) 1866 hw_cfg->bst_type = CS35L41_INT_BOOST; 1867 else 1868 hw_cfg->bst_type = CS35L41_EXT_BOOST; 1869 1870 hw_cfg->valid = true; 1871 1872 return 0; 1873 err: 1874 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret); 1875 hw_cfg->valid = false; 1876 hw_cfg->gpio1.valid = false; 1877 hw_cfg->gpio2.valid = false; 1878 acpi_dev_put(cs35l41->dacpi); 1879 1880 return ret; 1881 } 1882 1883 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id) 1884 { 1885 struct acpi_device *adev; 1886 struct device *physdev; 1887 struct spi_device *spi; 1888 const char *sub; 1889 int ret; 1890 1891 adev = acpi_dev_get_first_match_dev(hid, NULL, -1); 1892 if (!adev) { 1893 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid); 1894 return -ENODEV; 1895 } 1896 1897 cs35l41->dacpi = adev; 1898 physdev = get_device(acpi_get_first_physical_node(adev)); 1899 if (!physdev) 1900 return -ENODEV; 1901 1902 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev)); 1903 if (IS_ERR(sub)) 1904 sub = NULL; 1905 cs35l41->acpi_subsystem_id = sub; 1906 1907 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid); 1908 if (!ret) { 1909 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n"); 1910 goto out; 1911 } 1912 1913 ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id); 1914 if (ret) { 1915 put_device(physdev); 1916 return ret; 1917 } 1918 out: 1919 put_device(physdev); 1920 1921 cs35l41->bypass_fw = false; 1922 if (cs35l41->control_bus == SPI) { 1923 spi = to_spi_device(cs35l41->dev); 1924 if (spi->max_speed_hz < CS35L41_MAX_ACCEPTABLE_SPI_SPEED_HZ) { 1925 dev_warn(cs35l41->dev, 1926 "SPI speed is too slow to support firmware download: %d Hz.\n", 1927 spi->max_speed_hz); 1928 cs35l41->bypass_fw = true; 1929 } 1930 } 1931 1932 return 0; 1933 } 1934 1935 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq, 1936 struct regmap *regmap, enum control_bus control_bus) 1937 { 1938 unsigned int regid, reg_revid; 1939 struct cs35l41_hda *cs35l41; 1940 int ret; 1941 1942 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs)); 1943 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ); 1944 1945 if (IS_ERR(regmap)) 1946 return PTR_ERR(regmap); 1947 1948 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL); 1949 if (!cs35l41) 1950 return -ENOMEM; 1951 1952 cs35l41->dev = dev; 1953 cs35l41->irq = irq; 1954 cs35l41->regmap = regmap; 1955 cs35l41->control_bus = control_bus; 1956 dev_set_drvdata(dev, cs35l41); 1957 1958 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id); 1959 if (ret) 1960 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n"); 1961 1962 if (IS_ERR(cs35l41->reset_gpio)) { 1963 ret = PTR_ERR(cs35l41->reset_gpio); 1964 cs35l41->reset_gpio = NULL; 1965 if (ret == -EBUSY) { 1966 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n"); 1967 } else { 1968 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n"); 1969 goto err; 1970 } 1971 } 1972 if (cs35l41->reset_gpio) { 1973 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 1974 usleep_range(2000, 2100); 1975 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 1976 } 1977 1978 usleep_range(2000, 2100); 1979 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET); 1980 usleep_range(2000, 2100); 1981 1982 ret = cs35l41_wait_boot_done(cs35l41); 1983 if (ret) 1984 goto err; 1985 1986 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid); 1987 if (ret) 1988 goto err; 1989 1990 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 1991 if (ret) 1992 goto err; 1993 1994 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid); 1995 if (ret) 1996 goto err; 1997 1998 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap); 1999 if (ret) { 2000 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n"); 2001 goto err; 2002 } 2003 2004 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 2005 if (ret) 2006 goto err; 2007 2008 ret = cs35l41_get_calibration(cs35l41); 2009 if (ret && ret != -ENOENT) 2010 goto err; 2011 2012 cs35l41_mute(cs35l41->dev, true); 2013 2014 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work); 2015 mutex_init(&cs35l41->fw_mutex); 2016 2017 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000); 2018 pm_runtime_use_autosuspend(cs35l41->dev); 2019 pm_runtime_set_active(cs35l41->dev); 2020 pm_runtime_get_noresume(cs35l41->dev); 2021 pm_runtime_enable(cs35l41->dev); 2022 2023 ret = cs35l41_hda_apply_properties(cs35l41); 2024 if (ret) 2025 goto err_pm; 2026 2027 pm_runtime_put_autosuspend(cs35l41->dev); 2028 2029 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops); 2030 if (ret) { 2031 dev_err_probe(cs35l41->dev, ret, "Register component failed\n"); 2032 goto err_pm; 2033 } 2034 2035 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid); 2036 2037 return 0; 2038 2039 err_pm: 2040 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2041 pm_runtime_disable(cs35l41->dev); 2042 pm_runtime_put_noidle(cs35l41->dev); 2043 2044 err: 2045 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2046 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2047 gpiod_put(cs35l41->reset_gpio); 2048 gpiod_put(cs35l41->cs_gpio); 2049 acpi_dev_put(cs35l41->dacpi); 2050 kfree(cs35l41->acpi_subsystem_id); 2051 2052 return ret; 2053 } 2054 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, "SND_HDA_SCODEC_CS35L41"); 2055 2056 void cs35l41_hda_remove(struct device *dev) 2057 { 2058 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 2059 2060 component_del(cs35l41->dev, &cs35l41_hda_comp_ops); 2061 2062 pm_runtime_get_sync(cs35l41->dev); 2063 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2064 pm_runtime_disable(cs35l41->dev); 2065 2066 if (cs35l41->halo_initialized) 2067 cs35l41_remove_dsp(cs35l41); 2068 2069 acpi_dev_put(cs35l41->dacpi); 2070 2071 pm_runtime_put_noidle(cs35l41->dev); 2072 2073 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2074 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2075 gpiod_put(cs35l41->reset_gpio); 2076 gpiod_put(cs35l41->cs_gpio); 2077 kfree(cs35l41->acpi_subsystem_id); 2078 } 2079 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, "SND_HDA_SCODEC_CS35L41"); 2080 2081 const struct dev_pm_ops cs35l41_hda_pm_ops = { 2082 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, 2083 cs35l41_runtime_idle) 2084 .prepare = cs35l41_system_suspend_prep, 2085 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume) 2086 }; 2087 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, "SND_HDA_SCODEC_CS35L41"); 2088 2089 MODULE_DESCRIPTION("CS35L41 HDA Driver"); 2090 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB"); 2091 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>"); 2092 MODULE_LICENSE("GPL"); 2093 MODULE_IMPORT_NS("FW_CS_DSP"); 2094 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw"); 2095 MODULE_FIRMWARE("cirrus/cs35l41-*.bin"); 2096