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