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 void cs35l41_remove_controls(struct cs35l41_hda *cs35l41) 1329 { 1330 if (!cs35l41->codec) 1331 return; 1332 1333 snd_ctl_remove(cs35l41->codec->card, cs35l41->mute_override_ctl); 1334 cs35l41->mute_override_ctl = NULL; 1335 1336 snd_ctl_remove(cs35l41->codec->card, cs35l41->fw_load_ctl); 1337 cs35l41->fw_load_ctl = NULL; 1338 1339 snd_ctl_remove(cs35l41->codec->card, cs35l41->fw_type_ctl); 1340 cs35l41->fw_type_ctl = NULL; 1341 } 1342 1343 static int cs35l41_add_control(struct cs35l41_hda *cs35l41, 1344 struct snd_kcontrol_new *ctl, 1345 struct snd_kcontrol **kctl) 1346 { 1347 int ret; 1348 1349 *kctl = snd_ctl_new1(ctl, cs35l41); 1350 if (!*kctl) 1351 return -ENOMEM; 1352 1353 ret = snd_ctl_add(cs35l41->codec->card, *kctl); 1354 if (ret) { 1355 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", ctl->name, ret); 1356 *kctl = NULL; 1357 return ret; 1358 } 1359 1360 dev_dbg(cs35l41->dev, "Added Control %s\n", ctl->name); 1361 1362 return 0; 1363 } 1364 1365 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41) 1366 { 1367 char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1368 char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1369 char mute_override_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1370 struct snd_kcontrol_new fw_type_ctl = { 1371 .name = fw_type_ctl_name, 1372 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1373 .info = cs35l41_fw_type_ctl_info, 1374 .get = cs35l41_fw_type_ctl_get, 1375 .put = cs35l41_fw_type_ctl_put, 1376 }; 1377 struct snd_kcontrol_new fw_load_ctl = { 1378 .name = fw_load_ctl_name, 1379 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1380 .info = snd_ctl_boolean_mono_info, 1381 .get = cs35l41_fw_load_ctl_get, 1382 .put = cs35l41_fw_load_ctl_put, 1383 }; 1384 struct snd_kcontrol_new mute_override_ctl = { 1385 .name = mute_override_ctl_name, 1386 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1387 .info = snd_ctl_boolean_mono_info, 1388 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1389 .get = cs35l41_mute_override_ctl_get, 1390 }; 1391 int ret; 1392 1393 scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type", 1394 cs35l41->amp_name); 1395 scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load", 1396 cs35l41->amp_name); 1397 scnprintf(mute_override_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s Forced Mute Status", 1398 cs35l41->amp_name); 1399 1400 ret = cs35l41_add_control(cs35l41, &fw_type_ctl, &cs35l41->fw_type_ctl); 1401 if (ret) 1402 goto err; 1403 1404 ret = cs35l41_add_control(cs35l41, &fw_load_ctl, &cs35l41->fw_load_ctl); 1405 if (ret) 1406 goto err; 1407 1408 ret = cs35l41_add_control(cs35l41, &mute_override_ctl, &cs35l41->mute_override_ctl); 1409 if (ret) 1410 goto err; 1411 1412 return 0; 1413 1414 err: 1415 cs35l41_remove_controls(cs35l41); 1416 return ret; 1417 } 1418 1419 static bool cs35l41_dsm_supported(acpi_handle handle, unsigned int commands) 1420 { 1421 guid_t guid; 1422 1423 guid_parse(CS35L41_UUID, &guid); 1424 1425 return acpi_check_dsm(handle, &guid, 0, BIT(commands)); 1426 } 1427 1428 static int cs35l41_get_acpi_mute_state(struct cs35l41_hda *cs35l41, acpi_handle handle) 1429 { 1430 guid_t guid; 1431 union acpi_object *ret; 1432 int mute = -ENODEV; 1433 1434 guid_parse(CS35L41_UUID, &guid); 1435 1436 if (cs35l41_dsm_supported(handle, CS35L41_DSM_GET_MUTE)) { 1437 ret = acpi_evaluate_dsm_typed(handle, &guid, 0, 1438 CS35L41_DSM_GET_MUTE, NULL, 1439 ACPI_TYPE_BUFFER); 1440 1441 if (!ret) 1442 return -EINVAL; 1443 if (!ret->buffer.length || !ret->buffer.pointer) { 1444 ACPI_FREE(ret); 1445 return -EINVAL; 1446 } 1447 1448 mute = *ret->buffer.pointer; 1449 ACPI_FREE(ret); 1450 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute); 1451 } 1452 1453 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute); 1454 1455 return mute; 1456 } 1457 1458 static void cs35l41_acpi_device_notify(acpi_handle handle, u32 event, struct device *dev) 1459 { 1460 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1461 int mute; 1462 1463 if (event != CS35L41_NOTIFY_EVENT) 1464 return; 1465 1466 mute = cs35l41_get_acpi_mute_state(cs35l41, handle); 1467 if (mute < 0) { 1468 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute); 1469 return; 1470 } 1471 1472 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute); 1473 cs35l41->mute_override = (mute > 0); 1474 cs35l41_mute(cs35l41->dev, cs35l41->mute_override); 1475 } 1476 1477 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data) 1478 { 1479 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1480 struct hda_component_parent *parent = master_data; 1481 struct hda_component *comp; 1482 unsigned int sleep_flags; 1483 int ret = 0; 1484 1485 comp = hda_component_from_index(parent, cs35l41->index); 1486 if (!comp) 1487 return -EINVAL; 1488 1489 if (comp->dev) 1490 return -EBUSY; 1491 1492 guard(pm_runtime_active_auto)(dev); 1493 1494 mutex_lock(&cs35l41->fw_mutex); 1495 1496 comp->dev = dev; 1497 cs35l41->codec = parent->codec; 1498 if (!cs35l41->acpi_subsystem_id) 1499 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x", 1500 cs35l41->codec->core.subsystem_id); 1501 1502 strscpy(comp->name, dev_name(dev), sizeof(comp->name)); 1503 1504 cs35l41->firmware_type = CS35L41_HDA_FW_SPK_PROT; 1505 1506 if (firmware_autostart) { 1507 dev_dbg(cs35l41->dev, "Firmware Autostart.\n"); 1508 cs35l41->request_fw_load = true; 1509 if (cs35l41_smart_amp(cs35l41) < 0) 1510 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n"); 1511 } else { 1512 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n"); 1513 } 1514 1515 ret = cs35l41_create_controls(cs35l41); 1516 1517 comp->playback_hook = cs35l41_hda_playback_hook; 1518 comp->pre_playback_hook = cs35l41_hda_pre_playback_hook; 1519 comp->post_playback_hook = cs35l41_hda_post_playback_hook; 1520 comp->acpi_notify = cs35l41_acpi_device_notify; 1521 comp->adev = cs35l41->dacpi; 1522 1523 comp->acpi_notifications_supported = cs35l41_dsm_supported(acpi_device_handle(comp->adev), 1524 CS35L41_DSM_GET_MUTE); 1525 1526 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41, 1527 acpi_device_handle(cs35l41->dacpi)) > 0; 1528 1529 mutex_unlock(&cs35l41->fw_mutex); 1530 1531 sleep_flags = lock_system_sleep(); 1532 if (!device_link_add(&cs35l41->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS)) 1533 dev_warn(dev, "Unable to create device link\n"); 1534 unlock_system_sleep(sleep_flags); 1535 1536 dev_info(cs35l41->dev, 1537 "CS35L41 Bound - SSID: %s, BST: %d, VSPK: %d, CH: %c, FW EN: %d, SPKID: %d\n", 1538 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type, 1539 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH, 1540 channel_name[cs35l41->hw_cfg.spk_pos], 1541 cs35l41->cs_dsp.running, cs35l41->speaker_id); 1542 1543 return ret; 1544 } 1545 1546 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data) 1547 { 1548 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1549 struct hda_component_parent *parent = master_data; 1550 struct hda_component *comp; 1551 unsigned int sleep_flags; 1552 1553 comp = hda_component_from_index(parent, cs35l41->index); 1554 if (!comp) 1555 return; 1556 1557 if (comp->dev == dev) { 1558 sleep_flags = lock_system_sleep(); 1559 device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev); 1560 unlock_system_sleep(sleep_flags); 1561 memset(comp, 0, sizeof(*comp)); 1562 1563 cs35l41_remove_controls(cs35l41); 1564 cancel_work_sync(&cs35l41->fw_load_work); 1565 cs35l41->codec = NULL; 1566 } 1567 } 1568 1569 static const struct component_ops cs35l41_hda_comp_ops = { 1570 .bind = cs35l41_hda_bind, 1571 .unbind = cs35l41_hda_unbind, 1572 }; 1573 1574 static irqreturn_t cs35l41_bst_short_err(int irq, void *data) 1575 { 1576 struct cs35l41_hda *cs35l41 = data; 1577 1578 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n"); 1579 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1580 1581 return IRQ_HANDLED; 1582 } 1583 1584 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data) 1585 { 1586 struct cs35l41_hda *cs35l41 = data; 1587 1588 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n"); 1589 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1590 1591 return IRQ_HANDLED; 1592 } 1593 1594 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data) 1595 { 1596 struct cs35l41_hda *cs35l41 = data; 1597 1598 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n"); 1599 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1600 1601 return IRQ_HANDLED; 1602 } 1603 1604 static irqreturn_t cs35l41_temp_err(int irq, void *data) 1605 { 1606 struct cs35l41_hda *cs35l41 = data; 1607 1608 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n"); 1609 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1610 1611 return IRQ_HANDLED; 1612 } 1613 1614 static irqreturn_t cs35l41_temp_warn(int irq, void *data) 1615 { 1616 struct cs35l41_hda *cs35l41 = data; 1617 1618 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n"); 1619 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1620 1621 return IRQ_HANDLED; 1622 } 1623 1624 static irqreturn_t cs35l41_amp_short(int irq, void *data) 1625 { 1626 struct cs35l41_hda *cs35l41 = data; 1627 1628 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n"); 1629 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1630 1631 return IRQ_HANDLED; 1632 } 1633 1634 static const struct cs35l41_irq cs35l41_irqs[] = { 1635 CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err), 1636 CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err), 1637 CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err), 1638 CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn), 1639 CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err), 1640 CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short), 1641 }; 1642 1643 static const struct regmap_irq cs35l41_reg_irqs[] = { 1644 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR), 1645 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR), 1646 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR), 1647 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN), 1648 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR), 1649 CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR), 1650 }; 1651 1652 static const struct regmap_irq_chip cs35l41_regmap_irq_chip = { 1653 .name = "cs35l41 IRQ1 Controller", 1654 .status_base = CS35L41_IRQ1_STATUS1, 1655 .mask_base = CS35L41_IRQ1_MASK1, 1656 .ack_base = CS35L41_IRQ1_STATUS1, 1657 .num_regs = 4, 1658 .irqs = cs35l41_reg_irqs, 1659 .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs), 1660 .runtime_pm = true, 1661 }; 1662 1663 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol) 1664 { 1665 int irq; 1666 int ret; 1667 int i; 1668 1669 if (!cs35l41->irq) { 1670 dev_warn(cs35l41->dev, "No Interrupt Found"); 1671 goto err; 1672 } 1673 1674 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq, 1675 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1676 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data); 1677 if (ret) { 1678 dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret); 1679 goto err; 1680 } 1681 1682 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) { 1683 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq); 1684 if (irq < 0) { 1685 ret = irq; 1686 dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name, 1687 ret); 1688 goto err; 1689 } 1690 1691 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL, 1692 cs35l41_irqs[i].handler, 1693 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1694 cs35l41_irqs[i].name, cs35l41); 1695 if (ret) { 1696 dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.", 1697 cs35l41_irqs[i].name, ret); 1698 goto err; 1699 } 1700 } 1701 return; 1702 err: 1703 dev_warn(cs35l41->dev, 1704 "IRQ Config Failed. Amp errors may not be recoverable without reboot."); 1705 } 1706 1707 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41) 1708 { 1709 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1710 bool using_irq = false; 1711 int irq_pol; 1712 int ret; 1713 1714 if (!cs35l41->hw_cfg.valid) 1715 return -EINVAL; 1716 1717 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg); 1718 if (ret) 1719 return ret; 1720 1721 if (hw_cfg->gpio1.valid) { 1722 switch (hw_cfg->gpio1.func) { 1723 case CS35L41_NOT_USED: 1724 break; 1725 case CS35l41_VSPK_SWITCH: 1726 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO; 1727 hw_cfg->gpio1.out_en = true; 1728 break; 1729 case CS35l41_SYNC: 1730 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC; 1731 break; 1732 default: 1733 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n", 1734 hw_cfg->gpio1.func); 1735 return -EINVAL; 1736 } 1737 } 1738 1739 if (hw_cfg->gpio2.valid) { 1740 switch (hw_cfg->gpio2.func) { 1741 case CS35L41_NOT_USED: 1742 break; 1743 case CS35L41_INTERRUPT: 1744 using_irq = true; 1745 hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN; 1746 break; 1747 default: 1748 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func); 1749 return -EINVAL; 1750 } 1751 } 1752 1753 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg); 1754 1755 if (using_irq) 1756 cs35l41_configure_interrupt(cs35l41, irq_pol); 1757 1758 return cs35l41_hda_channel_map(cs35l41); 1759 } 1760 1761 int cs35l41_get_speaker_id(struct device *dev, int amp_index, int num_amps, int fixed_gpio_id) 1762 { 1763 struct gpio_desc *speaker_id_desc; 1764 int speaker_id = -ENODEV; 1765 1766 if (fixed_gpio_id >= 0) { 1767 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id); 1768 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN); 1769 if (IS_ERR(speaker_id_desc)) { 1770 speaker_id = PTR_ERR(speaker_id_desc); 1771 return speaker_id; 1772 } 1773 speaker_id = gpiod_get_value_cansleep(speaker_id_desc); 1774 gpiod_put(speaker_id_desc); 1775 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1776 } else { 1777 int base_index; 1778 int gpios_per_amp; 1779 int count; 1780 int tmp; 1781 int i; 1782 1783 count = gpiod_count(dev, "spk-id"); 1784 if (count > 0) { 1785 speaker_id = 0; 1786 gpios_per_amp = count / num_amps; 1787 base_index = gpios_per_amp * amp_index; 1788 1789 if (count % num_amps) 1790 return -EINVAL; 1791 1792 dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp); 1793 1794 for (i = 0; i < gpios_per_amp; i++) { 1795 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index, 1796 GPIOD_IN); 1797 if (IS_ERR(speaker_id_desc)) { 1798 speaker_id = PTR_ERR(speaker_id_desc); 1799 break; 1800 } 1801 tmp = gpiod_get_value_cansleep(speaker_id_desc); 1802 gpiod_put(speaker_id_desc); 1803 if (tmp < 0) { 1804 speaker_id = tmp; 1805 break; 1806 } 1807 speaker_id |= tmp << i; 1808 } 1809 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1810 } 1811 } 1812 return speaker_id; 1813 } 1814 1815 int cs35l41_hda_parse_acpi(struct cs35l41_hda *cs35l41, struct device *physdev, int id) 1816 { 1817 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1818 u32 values[HDA_MAX_COMPONENTS]; 1819 char *property; 1820 size_t nval; 1821 int i, ret; 1822 1823 property = "cirrus,dev-index"; 1824 ret = device_property_count_u32(physdev, property); 1825 if (ret <= 0) 1826 goto err; 1827 1828 if (ret > ARRAY_SIZE(values)) { 1829 ret = -EINVAL; 1830 goto err; 1831 } 1832 nval = ret; 1833 1834 ret = device_property_read_u32_array(physdev, property, values, nval); 1835 if (ret) 1836 goto err; 1837 1838 cs35l41->index = -1; 1839 for (i = 0; i < nval; i++) { 1840 if (values[i] == id) { 1841 cs35l41->index = i; 1842 break; 1843 } 1844 } 1845 if (cs35l41->index == -1) { 1846 dev_err(cs35l41->dev, "No index found in %s\n", property); 1847 ret = -ENODEV; 1848 goto err; 1849 } 1850 1851 /* To use the same release code for all laptop variants we can't use devm_ version of 1852 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node 1853 */ 1854 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(cs35l41->dacpi), "reset", 1855 cs35l41->index, GPIOD_OUT_LOW, 1856 "cs35l41-reset"); 1857 1858 property = "cirrus,speaker-position"; 1859 ret = device_property_read_u32_array(physdev, property, values, nval); 1860 if (ret) 1861 goto err; 1862 hw_cfg->spk_pos = values[cs35l41->index]; 1863 1864 cs35l41->channel_index = 0; 1865 for (i = 0; i < cs35l41->index; i++) 1866 if (values[i] == hw_cfg->spk_pos) 1867 cs35l41->channel_index++; 1868 1869 property = "cirrus,gpio1-func"; 1870 ret = device_property_read_u32_array(physdev, property, values, nval); 1871 if (ret) 1872 goto err; 1873 hw_cfg->gpio1.func = values[cs35l41->index]; 1874 hw_cfg->gpio1.valid = true; 1875 1876 property = "cirrus,gpio2-func"; 1877 ret = device_property_read_u32_array(physdev, property, values, nval); 1878 if (ret) 1879 goto err; 1880 hw_cfg->gpio2.func = values[cs35l41->index]; 1881 hw_cfg->gpio2.valid = true; 1882 1883 property = "cirrus,boost-peak-milliamp"; 1884 ret = device_property_read_u32_array(physdev, property, values, nval); 1885 if (ret == 0) 1886 hw_cfg->bst_ipk = values[cs35l41->index]; 1887 else 1888 hw_cfg->bst_ipk = -1; 1889 1890 property = "cirrus,boost-ind-nanohenry"; 1891 ret = device_property_read_u32_array(physdev, property, values, nval); 1892 if (ret == 0) 1893 hw_cfg->bst_ind = values[cs35l41->index]; 1894 else 1895 hw_cfg->bst_ind = -1; 1896 1897 property = "cirrus,boost-cap-microfarad"; 1898 ret = device_property_read_u32_array(physdev, property, values, nval); 1899 if (ret == 0) 1900 hw_cfg->bst_cap = values[cs35l41->index]; 1901 else 1902 hw_cfg->bst_cap = -1; 1903 1904 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1); 1905 1906 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0) 1907 hw_cfg->bst_type = CS35L41_INT_BOOST; 1908 else 1909 hw_cfg->bst_type = CS35L41_EXT_BOOST; 1910 1911 hw_cfg->valid = true; 1912 1913 return 0; 1914 err: 1915 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret); 1916 hw_cfg->valid = false; 1917 hw_cfg->gpio1.valid = false; 1918 hw_cfg->gpio2.valid = false; 1919 acpi_dev_put(cs35l41->dacpi); 1920 1921 return ret; 1922 } 1923 1924 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id) 1925 { 1926 struct acpi_device *adev; 1927 struct device *physdev; 1928 struct spi_device *spi; 1929 const char *sub; 1930 int ret; 1931 1932 adev = acpi_dev_get_first_match_dev(hid, NULL, -1); 1933 if (!adev) { 1934 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid); 1935 return -ENODEV; 1936 } 1937 1938 cs35l41->dacpi = adev; 1939 physdev = get_device(acpi_get_first_physical_node(adev)); 1940 if (!physdev) { 1941 acpi_dev_put(adev); 1942 return -ENODEV; 1943 } 1944 1945 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev)); 1946 if (IS_ERR(sub)) 1947 sub = NULL; 1948 cs35l41->acpi_subsystem_id = sub; 1949 1950 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid); 1951 if (!ret) { 1952 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n"); 1953 goto out; 1954 } 1955 1956 ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id); 1957 if (ret) { 1958 put_device(physdev); 1959 return ret; 1960 } 1961 out: 1962 put_device(physdev); 1963 1964 cs35l41->bypass_fw = false; 1965 if (cs35l41->control_bus == SPI) { 1966 spi = to_spi_device(cs35l41->dev); 1967 if (spi->max_speed_hz < CS35L41_MAX_ACCEPTABLE_SPI_SPEED_HZ) { 1968 dev_warn(cs35l41->dev, 1969 "SPI speed is too slow to support firmware download: %d Hz.\n", 1970 spi->max_speed_hz); 1971 cs35l41->bypass_fw = true; 1972 } 1973 } 1974 1975 return 0; 1976 } 1977 1978 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq, 1979 struct regmap *regmap, enum control_bus control_bus) 1980 { 1981 unsigned int regid, reg_revid; 1982 struct cs35l41_hda *cs35l41; 1983 int ret; 1984 1985 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs)); 1986 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ); 1987 1988 if (IS_ERR(regmap)) 1989 return PTR_ERR(regmap); 1990 1991 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL); 1992 if (!cs35l41) 1993 return -ENOMEM; 1994 1995 cs35l41->dev = dev; 1996 cs35l41->irq = irq; 1997 cs35l41->regmap = regmap; 1998 cs35l41->control_bus = control_bus; 1999 dev_set_drvdata(dev, cs35l41); 2000 2001 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id); 2002 if (ret) 2003 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n"); 2004 2005 if (IS_ERR(cs35l41->reset_gpio)) { 2006 ret = PTR_ERR(cs35l41->reset_gpio); 2007 cs35l41->reset_gpio = NULL; 2008 if (ret == -EBUSY) { 2009 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n"); 2010 } else { 2011 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n"); 2012 goto err; 2013 } 2014 } 2015 if (cs35l41->reset_gpio) { 2016 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2017 usleep_range(2000, 2100); 2018 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 2019 } 2020 2021 usleep_range(2000, 2100); 2022 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET); 2023 usleep_range(2000, 2100); 2024 2025 ret = cs35l41_wait_boot_done(cs35l41); 2026 if (ret) 2027 goto err; 2028 2029 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid); 2030 if (ret) 2031 goto err; 2032 2033 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 2034 if (ret) 2035 goto err; 2036 2037 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid); 2038 if (ret) 2039 goto err; 2040 2041 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap); 2042 if (ret) { 2043 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n"); 2044 goto err; 2045 } 2046 2047 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 2048 if (ret) 2049 goto err; 2050 2051 ret = cs35l41_get_calibration(cs35l41); 2052 if (ret && ret != -ENOENT) 2053 goto err; 2054 2055 cs35l41_mute(cs35l41->dev, true); 2056 2057 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work); 2058 mutex_init(&cs35l41->fw_mutex); 2059 2060 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000); 2061 pm_runtime_use_autosuspend(cs35l41->dev); 2062 pm_runtime_set_active(cs35l41->dev); 2063 pm_runtime_get_noresume(cs35l41->dev); 2064 pm_runtime_enable(cs35l41->dev); 2065 2066 ret = cs35l41_hda_apply_properties(cs35l41); 2067 if (ret) 2068 goto err_pm; 2069 2070 pm_runtime_put_autosuspend(cs35l41->dev); 2071 2072 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops); 2073 if (ret) { 2074 dev_err_probe(cs35l41->dev, ret, "Register component failed\n"); 2075 goto err_pm; 2076 } 2077 2078 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid); 2079 2080 return 0; 2081 2082 err_pm: 2083 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2084 pm_runtime_disable(cs35l41->dev); 2085 pm_runtime_put_noidle(cs35l41->dev); 2086 2087 err: 2088 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2089 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2090 gpiod_put(cs35l41->reset_gpio); 2091 gpiod_put(cs35l41->cs_gpio); 2092 acpi_dev_put(cs35l41->dacpi); 2093 kfree(cs35l41->acpi_subsystem_id); 2094 2095 return ret; 2096 } 2097 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, "SND_HDA_SCODEC_CS35L41"); 2098 2099 void cs35l41_hda_remove(struct device *dev) 2100 { 2101 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 2102 2103 component_del(cs35l41->dev, &cs35l41_hda_comp_ops); 2104 cancel_work_sync(&cs35l41->fw_load_work); 2105 2106 pm_runtime_get_sync(cs35l41->dev); 2107 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2108 pm_runtime_disable(cs35l41->dev); 2109 2110 if (cs35l41->halo_initialized) 2111 cs35l41_remove_dsp(cs35l41); 2112 2113 acpi_dev_put(cs35l41->dacpi); 2114 2115 pm_runtime_put_noidle(cs35l41->dev); 2116 2117 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2118 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2119 gpiod_put(cs35l41->reset_gpio); 2120 gpiod_put(cs35l41->cs_gpio); 2121 kfree(cs35l41->acpi_subsystem_id); 2122 } 2123 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, "SND_HDA_SCODEC_CS35L41"); 2124 2125 const struct dev_pm_ops cs35l41_hda_pm_ops = { 2126 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, 2127 cs35l41_runtime_idle) 2128 .prepare = cs35l41_system_suspend_prep, 2129 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume) 2130 }; 2131 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, "SND_HDA_SCODEC_CS35L41"); 2132 2133 MODULE_DESCRIPTION("CS35L41 HDA Driver"); 2134 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB"); 2135 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>"); 2136 MODULE_LICENSE("GPL"); 2137 MODULE_IMPORT_NS("FW_CS_DSP"); 2138 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw"); 2139 MODULE_FIRMWARE("cirrus/cs35l41-*.bin"); 2140