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