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(handle, &guid, 0, CS35L41_DSM_GET_MUTE, NULL); 1438 if (!ret) 1439 return -EINVAL; 1440 mute = *ret->buffer.pointer; 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 device *physdev; 1919 struct spi_device *spi; 1920 const char *sub; 1921 int ret; 1922 1923 adev = acpi_dev_get_first_match_dev(hid, NULL, -1); 1924 if (!adev) { 1925 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid); 1926 return -ENODEV; 1927 } 1928 1929 cs35l41->dacpi = adev; 1930 physdev = get_device(acpi_get_first_physical_node(adev)); 1931 if (!physdev) { 1932 acpi_dev_put(adev); 1933 return -ENODEV; 1934 } 1935 1936 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev)); 1937 if (IS_ERR(sub)) 1938 sub = NULL; 1939 cs35l41->acpi_subsystem_id = sub; 1940 1941 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid); 1942 if (!ret) { 1943 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n"); 1944 goto out; 1945 } 1946 1947 ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id); 1948 if (ret) { 1949 put_device(physdev); 1950 return ret; 1951 } 1952 out: 1953 put_device(physdev); 1954 1955 cs35l41->bypass_fw = false; 1956 if (cs35l41->control_bus == SPI) { 1957 spi = to_spi_device(cs35l41->dev); 1958 if (spi->max_speed_hz < CS35L41_MAX_ACCEPTABLE_SPI_SPEED_HZ) { 1959 dev_warn(cs35l41->dev, 1960 "SPI speed is too slow to support firmware download: %d Hz.\n", 1961 spi->max_speed_hz); 1962 cs35l41->bypass_fw = true; 1963 } 1964 } 1965 1966 return 0; 1967 } 1968 1969 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq, 1970 struct regmap *regmap, enum control_bus control_bus) 1971 { 1972 unsigned int regid, reg_revid; 1973 struct cs35l41_hda *cs35l41; 1974 int ret; 1975 1976 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs)); 1977 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ); 1978 1979 if (IS_ERR(regmap)) 1980 return PTR_ERR(regmap); 1981 1982 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL); 1983 if (!cs35l41) 1984 return -ENOMEM; 1985 1986 cs35l41->dev = dev; 1987 cs35l41->irq = irq; 1988 cs35l41->regmap = regmap; 1989 cs35l41->control_bus = control_bus; 1990 dev_set_drvdata(dev, cs35l41); 1991 1992 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id); 1993 if (ret) 1994 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n"); 1995 1996 if (IS_ERR(cs35l41->reset_gpio)) { 1997 ret = PTR_ERR(cs35l41->reset_gpio); 1998 cs35l41->reset_gpio = NULL; 1999 if (ret == -EBUSY) { 2000 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n"); 2001 } else { 2002 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n"); 2003 goto err; 2004 } 2005 } 2006 if (cs35l41->reset_gpio) { 2007 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2008 usleep_range(2000, 2100); 2009 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 2010 } 2011 2012 usleep_range(2000, 2100); 2013 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET); 2014 usleep_range(2000, 2100); 2015 2016 ret = cs35l41_wait_boot_done(cs35l41); 2017 if (ret) 2018 goto err; 2019 2020 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid); 2021 if (ret) 2022 goto err; 2023 2024 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 2025 if (ret) 2026 goto err; 2027 2028 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid); 2029 if (ret) 2030 goto err; 2031 2032 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap); 2033 if (ret) { 2034 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n"); 2035 goto err; 2036 } 2037 2038 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 2039 if (ret) 2040 goto err; 2041 2042 ret = cs35l41_get_calibration(cs35l41); 2043 if (ret && ret != -ENOENT) 2044 goto err; 2045 2046 cs35l41_mute(cs35l41->dev, true); 2047 2048 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work); 2049 mutex_init(&cs35l41->fw_mutex); 2050 2051 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000); 2052 pm_runtime_use_autosuspend(cs35l41->dev); 2053 pm_runtime_set_active(cs35l41->dev); 2054 pm_runtime_get_noresume(cs35l41->dev); 2055 pm_runtime_enable(cs35l41->dev); 2056 2057 ret = cs35l41_hda_apply_properties(cs35l41); 2058 if (ret) 2059 goto err_pm; 2060 2061 pm_runtime_put_autosuspend(cs35l41->dev); 2062 2063 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops); 2064 if (ret) { 2065 dev_err_probe(cs35l41->dev, ret, "Register component failed\n"); 2066 goto err_pm; 2067 } 2068 2069 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid); 2070 2071 return 0; 2072 2073 err_pm: 2074 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2075 pm_runtime_disable(cs35l41->dev); 2076 pm_runtime_put_noidle(cs35l41->dev); 2077 2078 err: 2079 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2080 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2081 gpiod_put(cs35l41->reset_gpio); 2082 gpiod_put(cs35l41->cs_gpio); 2083 acpi_dev_put(cs35l41->dacpi); 2084 kfree(cs35l41->acpi_subsystem_id); 2085 2086 return ret; 2087 } 2088 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, "SND_HDA_SCODEC_CS35L41"); 2089 2090 void cs35l41_hda_remove(struct device *dev) 2091 { 2092 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 2093 2094 component_del(cs35l41->dev, &cs35l41_hda_comp_ops); 2095 cancel_work_sync(&cs35l41->fw_load_work); 2096 2097 pm_runtime_get_sync(cs35l41->dev); 2098 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2099 pm_runtime_disable(cs35l41->dev); 2100 2101 if (cs35l41->halo_initialized) 2102 cs35l41_remove_dsp(cs35l41); 2103 2104 acpi_dev_put(cs35l41->dacpi); 2105 2106 pm_runtime_put_noidle(cs35l41->dev); 2107 2108 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2109 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2110 gpiod_put(cs35l41->reset_gpio); 2111 gpiod_put(cs35l41->cs_gpio); 2112 kfree(cs35l41->acpi_subsystem_id); 2113 } 2114 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, "SND_HDA_SCODEC_CS35L41"); 2115 2116 const struct dev_pm_ops cs35l41_hda_pm_ops = { 2117 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, 2118 cs35l41_runtime_idle) 2119 .prepare = cs35l41_system_suspend_prep, 2120 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume) 2121 }; 2122 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, "SND_HDA_SCODEC_CS35L41"); 2123 2124 MODULE_DESCRIPTION("CS35L41 HDA Driver"); 2125 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB"); 2126 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>"); 2127 MODULE_LICENSE("GPL"); 2128 MODULE_IMPORT_NS("FW_CS_DSP"); 2129 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw"); 2130 MODULE_FIRMWARE("cirrus/cs35l41-*.bin"); 2131