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 mutex_lock(&cs35l41->fw_mutex); 628 cs35l41_shutdown_dsp(cs35l41); 629 cs_dsp_remove(dsp); 630 cs35l41->halo_initialized = false; 631 mutex_unlock(&cs35l41->fw_mutex); 632 } 633 634 /* Protection release cycle to get the speaker out of Safe-Mode */ 635 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask) 636 { 637 regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0); 638 regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask); 639 regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask); 640 } 641 642 /* Clear all errors to release safe mode. Global Enable must be cleared first. */ 643 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41) 644 { 645 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors); 646 cs35l41->irq_errors = 0; 647 } 648 649 static void cs35l41_update_mixer(struct cs35l41_hda *cs35l41) 650 { 651 struct regmap *reg = cs35l41->regmap; 652 unsigned int asp_en = 0; 653 unsigned int dsp1rx2_src = 0; 654 655 regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config)); 656 657 if (cs35l41->cs_dsp.running) { 658 asp_en |= CS35L41_ASP_TX1_EN_MASK; // ASP_TX1_EN = 1 659 regmap_multi_reg_write(reg, cs35l41_hda_config_dsp, 660 ARRAY_SIZE(cs35l41_hda_config_dsp)); 661 if (cs35l41->hw_cfg.bst_type == CS35L41_INT_BOOST) 662 regmap_write(reg, CS35L41_DSP1_RX5_SRC, CS35L41_INPUT_SRC_VPMON); 663 else 664 regmap_write(reg, CS35L41_DSP1_RX5_SRC, CS35L41_INPUT_SRC_VBSTMON); 665 } else { 666 regmap_multi_reg_write(reg, cs35l41_hda_config_no_dsp, 667 ARRAY_SIZE(cs35l41_hda_config_no_dsp)); 668 } 669 670 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER) { 671 asp_en |= CS35L41_ASP_RX2_EN_MASK; // ASP_RX2_EN = 1 672 dsp1rx2_src = 0x00000009; // DSP1RX2 SRC = ASPRX2 673 } else { 674 dsp1rx2_src = 0x00000008; // DSP1RX2 SRC = ASPRX1 675 } 676 677 asp_en |= CS35L41_ASP_RX1_EN_MASK; // ASP_RX1_EN = 1 678 679 regmap_write(reg, CS35L41_SP_ENABLES, asp_en); 680 regmap_write(reg, CS35L41_DSP1_RX1_SRC, 0x00000008); // DSP1RX1 SRC = ASPRX1 681 regmap_write(reg, CS35L41_DSP1_RX2_SRC, dsp1rx2_src); 682 } 683 684 static void cs35l41_hda_play_start(struct device *dev) 685 { 686 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 687 struct regmap *reg = cs35l41->regmap; 688 689 dev_dbg(dev, "Play (Start)\n"); 690 691 if (cs35l41->playback_started) { 692 dev_dbg(dev, "Playback already started."); 693 return; 694 } 695 696 cs35l41->playback_started = true; 697 698 cs35l41_update_mixer(cs35l41); 699 700 if (cs35l41->cs_dsp.running) { 701 regmap_update_bits(reg, CS35L41_PWR_CTRL2, 702 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 703 1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT); 704 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME); 705 } 706 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT); 707 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 708 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001); 709 710 } 711 712 static void cs35l41_mute(struct device *dev, bool mute) 713 { 714 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 715 struct regmap *reg = cs35l41->regmap; 716 unsigned int amp_gain; 717 718 dev_dbg(dev, "Mute(%d:%d) Playback Started: %d\n", mute, cs35l41->mute_override, 719 cs35l41->playback_started); 720 721 if (cs35l41->playback_started) { 722 if (mute || cs35l41->mute_override) { 723 dev_dbg(dev, "Muting\n"); 724 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute)); 725 } else { 726 dev_dbg(dev, "Unmuting\n"); 727 if (cs35l41->cs_dsp.running) { 728 dev_dbg(dev, "Using Tuned Gain: %d\n", cs35l41->tuning_gain); 729 amp_gain = (cs35l41->tuning_gain << CS35L41_AMP_GAIN_PCM_SHIFT) | 730 (DEFAULT_AMP_GAIN_PDM << CS35L41_AMP_GAIN_PDM_SHIFT); 731 732 /* AMP_HPF_PCM_EN = 1, AMP_VOL_PCM 0.0 dB */ 733 regmap_write(reg, CS35L41_AMP_DIG_VOL_CTRL, 0x00008000); 734 regmap_write(reg, CS35L41_AMP_GAIN_CTRL, amp_gain); 735 } else { 736 regmap_multi_reg_write(reg, cs35l41_hda_unmute, 737 ARRAY_SIZE(cs35l41_hda_unmute)); 738 } 739 } 740 } 741 } 742 743 static void cs35l41_hda_play_done(struct device *dev) 744 { 745 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 746 struct regmap *reg = cs35l41->regmap; 747 748 dev_dbg(dev, "Play (Complete)\n"); 749 750 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, 751 &cs35l41->cs_dsp); 752 cs35l41_mute(dev, false); 753 } 754 755 static void cs35l41_hda_pause_start(struct device *dev) 756 { 757 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 758 struct regmap *reg = cs35l41->regmap; 759 760 dev_dbg(dev, "Pause (Start)\n"); 761 762 cs35l41_mute(dev, true); 763 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, 764 &cs35l41->cs_dsp); 765 } 766 767 static void cs35l41_hda_pause_done(struct device *dev) 768 { 769 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 770 struct regmap *reg = cs35l41->regmap; 771 772 dev_dbg(dev, "Pause (Complete)\n"); 773 774 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT); 775 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 776 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001); 777 if (cs35l41->cs_dsp.running) { 778 cs35l41_set_cspl_mbox_cmd(dev, reg, CSPL_MBOX_CMD_PAUSE); 779 regmap_update_bits(reg, CS35L41_PWR_CTRL2, 780 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 781 0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT); 782 } 783 cs35l41_irq_release(cs35l41); 784 cs35l41->playback_started = false; 785 } 786 787 static void cs35l41_hda_pre_playback_hook(struct device *dev, int action) 788 { 789 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 790 791 switch (action) { 792 case HDA_GEN_PCM_ACT_CLEANUP: 793 mutex_lock(&cs35l41->fw_mutex); 794 cs35l41_hda_pause_start(dev); 795 mutex_unlock(&cs35l41->fw_mutex); 796 break; 797 default: 798 break; 799 } 800 } 801 static void cs35l41_hda_playback_hook(struct device *dev, int action) 802 { 803 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 804 805 switch (action) { 806 case HDA_GEN_PCM_ACT_OPEN: 807 /* 808 * All amps must be resumed before we can start playing back. 809 * This ensures, for external boost, that all amps are in AMP_SAFE mode. 810 * Do this in HDA_GEN_PCM_ACT_OPEN, since this is run prior to any of the 811 * other actions. 812 */ 813 pm_runtime_get_sync(dev); 814 break; 815 case HDA_GEN_PCM_ACT_PREPARE: 816 mutex_lock(&cs35l41->fw_mutex); 817 cs35l41_hda_play_start(dev); 818 mutex_unlock(&cs35l41->fw_mutex); 819 break; 820 case HDA_GEN_PCM_ACT_CLEANUP: 821 mutex_lock(&cs35l41->fw_mutex); 822 cs35l41_hda_pause_done(dev); 823 mutex_unlock(&cs35l41->fw_mutex); 824 break; 825 case HDA_GEN_PCM_ACT_CLOSE: 826 mutex_lock(&cs35l41->fw_mutex); 827 if (!cs35l41->cs_dsp.running && cs35l41->request_fw_load && 828 !cs35l41->fw_request_ongoing) { 829 dev_info(dev, "Requesting Firmware Load after HDA_GEN_PCM_ACT_CLOSE\n"); 830 cs35l41->fw_request_ongoing = true; 831 schedule_work(&cs35l41->fw_load_work); 832 } 833 mutex_unlock(&cs35l41->fw_mutex); 834 835 /* 836 * Playback must be finished for all amps before we start runtime suspend. 837 * This ensures no amps are playing back when we start putting them to sleep. 838 */ 839 pm_runtime_put_autosuspend(dev); 840 break; 841 default: 842 break; 843 } 844 } 845 846 static void cs35l41_hda_post_playback_hook(struct device *dev, int action) 847 { 848 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 849 850 switch (action) { 851 case HDA_GEN_PCM_ACT_PREPARE: 852 mutex_lock(&cs35l41->fw_mutex); 853 cs35l41_hda_play_done(dev); 854 mutex_unlock(&cs35l41->fw_mutex); 855 break; 856 default: 857 break; 858 } 859 } 860 861 static int cs35l41_hda_channel_map(struct cs35l41_hda *cs35l41) 862 { 863 unsigned int tx_num = 0; 864 unsigned int *tx_slot = NULL; 865 unsigned int rx_num; 866 unsigned int *rx_slot; 867 unsigned int mono = 0; 868 869 if (!cs35l41->amp_name) { 870 if (cs35l41->hw_cfg.spk_pos >= ARRAY_SIZE(channel_name)) 871 return -EINVAL; 872 873 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%c%d", 874 channel_name[cs35l41->hw_cfg.spk_pos], 875 cs35l41->channel_index); 876 if (!cs35l41->amp_name) 877 return -ENOMEM; 878 } 879 880 rx_num = 1; 881 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER) 882 rx_slot = &mono; 883 else 884 rx_slot = &cs35l41->hw_cfg.spk_pos; 885 886 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num, 887 rx_slot); 888 } 889 890 static int cs35l41_verify_id(struct cs35l41_hda *cs35l41, unsigned int *regid, unsigned int *reg_revid) 891 { 892 unsigned int mtl_revid, chipid; 893 int ret; 894 895 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, regid); 896 if (ret) { 897 dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n"); 898 return ret; 899 } 900 901 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, reg_revid); 902 if (ret) { 903 dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n"); 904 return ret; 905 } 906 907 mtl_revid = *reg_revid & CS35L41_MTLREVID_MASK; 908 909 chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID; 910 if (*regid != chipid) { 911 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", *regid, chipid); 912 return -ENODEV; 913 } 914 915 return 0; 916 } 917 918 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41) 919 { 920 mutex_lock(&cs35l41->fw_mutex); 921 if (cs35l41->cs_dsp.running) { 922 cs35l41->cs_dsp.running = false; 923 cs35l41->cs_dsp.booted = false; 924 } 925 regcache_mark_dirty(cs35l41->regmap); 926 mutex_unlock(&cs35l41->fw_mutex); 927 928 return 0; 929 } 930 931 static int cs35l41_system_suspend_prep(struct device *dev) 932 { 933 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 934 935 dev_dbg(cs35l41->dev, "System Suspend Prepare\n"); 936 937 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 938 dev_err_once(cs35l41->dev, "System Suspend not supported\n"); 939 return 0; /* don't block the whole system suspend */ 940 } 941 942 mutex_lock(&cs35l41->fw_mutex); 943 if (cs35l41->playback_started) 944 cs35l41_hda_pause_start(dev); 945 mutex_unlock(&cs35l41->fw_mutex); 946 947 return 0; 948 } 949 950 static int cs35l41_system_suspend(struct device *dev) 951 { 952 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 953 int ret; 954 955 dev_dbg(cs35l41->dev, "System Suspend\n"); 956 957 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 958 dev_err_once(cs35l41->dev, "System Suspend not supported\n"); 959 return 0; /* don't block the whole system suspend */ 960 } 961 962 mutex_lock(&cs35l41->fw_mutex); 963 if (cs35l41->playback_started) 964 cs35l41_hda_pause_done(dev); 965 mutex_unlock(&cs35l41->fw_mutex); 966 967 ret = pm_runtime_force_suspend(dev); 968 if (ret) { 969 dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret); 970 return ret; 971 } 972 973 /* Shutdown DSP before system suspend */ 974 ret = cs35l41_ready_for_reset(cs35l41); 975 if (ret) 976 dev_err(dev, "System Suspend Failed, not ready for Reset: %d\n", ret); 977 978 if (cs35l41->reset_gpio) { 979 dev_info(cs35l41->dev, "Asserting Reset\n"); 980 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 981 usleep_range(2000, 2100); 982 } 983 984 dev_dbg(cs35l41->dev, "System Suspended\n"); 985 986 return ret; 987 } 988 989 static int cs35l41_wait_boot_done(struct cs35l41_hda *cs35l41) 990 { 991 unsigned int int_status; 992 int ret; 993 994 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status, 995 int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000); 996 if (ret) { 997 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE\n"); 998 return ret; 999 } 1000 1001 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_status); 1002 if (ret || (int_status & CS35L41_OTP_BOOT_ERR)) { 1003 dev_err(cs35l41->dev, "OTP Boot status %x error\n", 1004 int_status & CS35L41_OTP_BOOT_ERR); 1005 if (!ret) 1006 ret = -EIO; 1007 return ret; 1008 } 1009 1010 return 0; 1011 } 1012 1013 static int cs35l41_system_resume(struct device *dev) 1014 { 1015 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1016 int ret; 1017 1018 dev_dbg(cs35l41->dev, "System Resume\n"); 1019 1020 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 1021 dev_err_once(cs35l41->dev, "System Resume not supported\n"); 1022 return 0; /* don't block the whole system resume */ 1023 } 1024 1025 if (cs35l41->reset_gpio) { 1026 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 1027 usleep_range(2000, 2100); 1028 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 1029 } 1030 1031 usleep_range(2000, 2100); 1032 1033 regcache_cache_only(cs35l41->regmap, false); 1034 1035 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET); 1036 usleep_range(2000, 2100); 1037 1038 ret = cs35l41_wait_boot_done(cs35l41); 1039 if (ret) 1040 return ret; 1041 1042 regcache_cache_only(cs35l41->regmap, true); 1043 1044 ret = pm_runtime_force_resume(dev); 1045 if (ret) { 1046 dev_err(dev, "System Resume Failed: Unable to runtime resume: %d\n", ret); 1047 return ret; 1048 } 1049 1050 mutex_lock(&cs35l41->fw_mutex); 1051 1052 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) { 1053 cs35l41->fw_request_ongoing = true; 1054 schedule_work(&cs35l41->fw_load_work); 1055 } 1056 mutex_unlock(&cs35l41->fw_mutex); 1057 1058 return ret; 1059 } 1060 1061 static int cs35l41_runtime_idle(struct device *dev) 1062 { 1063 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1064 1065 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) 1066 return -EBUSY; /* suspend not supported yet on this model */ 1067 return 0; 1068 } 1069 1070 static int cs35l41_runtime_suspend(struct device *dev) 1071 { 1072 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1073 int ret = 0; 1074 1075 dev_dbg(cs35l41->dev, "Runtime Suspend\n"); 1076 1077 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 1078 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n"); 1079 return 0; 1080 } 1081 1082 mutex_lock(&cs35l41->fw_mutex); 1083 1084 if (cs35l41->cs_dsp.running) { 1085 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap, 1086 cs35l41->hw_cfg.bst_type); 1087 if (ret) 1088 goto err; 1089 } else { 1090 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type); 1091 } 1092 1093 regcache_cache_only(cs35l41->regmap, true); 1094 regcache_mark_dirty(cs35l41->regmap); 1095 1096 err: 1097 mutex_unlock(&cs35l41->fw_mutex); 1098 1099 return ret; 1100 } 1101 1102 static int cs35l41_runtime_resume(struct device *dev) 1103 { 1104 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1105 unsigned int regid, reg_revid; 1106 int ret = 0; 1107 1108 dev_dbg(cs35l41->dev, "Runtime Resume\n"); 1109 1110 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 1111 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n"); 1112 return 0; 1113 } 1114 1115 mutex_lock(&cs35l41->fw_mutex); 1116 1117 regcache_cache_only(cs35l41->regmap, false); 1118 1119 if (cs35l41->cs_dsp.running) { 1120 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap); 1121 if (ret) { 1122 dev_warn(cs35l41->dev, "Unable to exit Hibernate."); 1123 goto err; 1124 } 1125 } 1126 1127 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid); 1128 if (ret) 1129 goto err; 1130 1131 /* Test key needs to be unlocked to allow the OTP settings to re-apply */ 1132 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 1133 ret = regcache_sync(cs35l41->regmap); 1134 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 1135 if (ret) { 1136 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret); 1137 goto err; 1138 } 1139 1140 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 1141 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg); 1142 1143 dev_dbg(cs35l41->dev, "CS35L41 Resumed (%x), Revision: %02X\n", regid, reg_revid); 1144 1145 err: 1146 mutex_unlock(&cs35l41->fw_mutex); 1147 1148 return ret; 1149 } 1150 1151 static int cs35l41_hda_read_ctl(struct cs_dsp *dsp, const char *name, int type, 1152 unsigned int alg, void *buf, size_t len) 1153 { 1154 int ret; 1155 1156 mutex_lock(&dsp->pwr_lock); 1157 ret = cs_dsp_coeff_read_ctrl(cs_dsp_get_ctl(dsp, name, type, alg), 0, buf, len); 1158 mutex_unlock(&dsp->pwr_lock); 1159 1160 return ret; 1161 } 1162 1163 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41) 1164 { 1165 unsigned int fw_status; 1166 __be32 halo_sts; 1167 int ret; 1168 1169 if (cs35l41->bypass_fw) { 1170 dev_warn(cs35l41->dev, "Bypassing Firmware.\n"); 1171 return 0; 1172 } 1173 1174 ret = cs35l41_init_dsp(cs35l41); 1175 if (ret) { 1176 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret); 1177 goto clean_dsp; 1178 } 1179 1180 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap); 1181 if (ret) { 1182 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret); 1183 goto clean_dsp; 1184 } 1185 1186 ret = cs_dsp_run(&cs35l41->cs_dsp); 1187 if (ret) { 1188 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret); 1189 goto clean_dsp; 1190 } 1191 1192 ret = read_poll_timeout(cs35l41_hda_read_ctl, ret, 1193 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN, 1194 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME, 1195 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG, 1196 &halo_sts, sizeof(halo_sts)); 1197 1198 if (ret) { 1199 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n", 1200 halo_sts); 1201 goto clean_dsp; 1202 } 1203 1204 ret = regmap_read(cs35l41->regmap, CS35L41_DSP_MBOX_2, &fw_status); 1205 if (ret < 0) { 1206 dev_err(cs35l41->dev, 1207 "Failed to read firmware status: %d\n", ret); 1208 goto clean_dsp; 1209 } 1210 1211 switch (fw_status) { 1212 case CSPL_MBOX_STS_RUNNING: 1213 case CSPL_MBOX_STS_PAUSED: 1214 break; 1215 default: 1216 dev_err(cs35l41->dev, "Firmware status is invalid: %u\n", 1217 fw_status); 1218 ret = -EINVAL; 1219 goto clean_dsp; 1220 } 1221 1222 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE); 1223 if (ret) { 1224 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret); 1225 goto clean_dsp; 1226 } 1227 1228 dev_info(cs35l41->dev, "Firmware Loaded - Type: %s, Gain: %d\n", 1229 cs35l41_hda_fw_ids[cs35l41->firmware_type], cs35l41->tuning_gain); 1230 1231 return 0; 1232 1233 clean_dsp: 1234 cs35l41_shutdown_dsp(cs35l41); 1235 return ret; 1236 } 1237 1238 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load) 1239 { 1240 if (cs35l41->cs_dsp.running && !load) { 1241 dev_dbg(cs35l41->dev, "Unloading Firmware\n"); 1242 cs35l41_shutdown_dsp(cs35l41); 1243 } else if (!cs35l41->cs_dsp.running && load) { 1244 dev_dbg(cs35l41->dev, "Loading Firmware\n"); 1245 cs35l41_smart_amp(cs35l41); 1246 } else { 1247 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n"); 1248 } 1249 } 1250 1251 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol, 1252 struct snd_ctl_elem_value *ucontrol) 1253 { 1254 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1255 1256 ucontrol->value.integer.value[0] = cs35l41->request_fw_load; 1257 return 0; 1258 } 1259 1260 static int cs35l41_mute_override_ctl_get(struct snd_kcontrol *kcontrol, 1261 struct snd_ctl_elem_value *ucontrol) 1262 { 1263 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1264 1265 ucontrol->value.integer.value[0] = cs35l41->mute_override; 1266 return 0; 1267 } 1268 1269 static void cs35l41_fw_load_work(struct work_struct *work) 1270 { 1271 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work); 1272 1273 pm_runtime_get_sync(cs35l41->dev); 1274 1275 mutex_lock(&cs35l41->fw_mutex); 1276 1277 /* Recheck if playback is ongoing, mutex will block playback during firmware loading */ 1278 if (cs35l41->playback_started) 1279 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n"); 1280 else 1281 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load); 1282 1283 cs35l41->fw_request_ongoing = false; 1284 mutex_unlock(&cs35l41->fw_mutex); 1285 1286 pm_runtime_put_autosuspend(cs35l41->dev); 1287 } 1288 1289 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol, 1290 struct snd_ctl_elem_value *ucontrol) 1291 { 1292 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1293 1294 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0]) 1295 return 0; 1296 1297 if (cs35l41->fw_request_ongoing) { 1298 dev_dbg(cs35l41->dev, "Existing request not complete\n"); 1299 return -EBUSY; 1300 } 1301 1302 /* Check if playback is ongoing when initial request is made */ 1303 if (cs35l41->playback_started) { 1304 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n"); 1305 return -EBUSY; 1306 } 1307 1308 cs35l41->fw_request_ongoing = true; 1309 cs35l41->request_fw_load = ucontrol->value.integer.value[0]; 1310 schedule_work(&cs35l41->fw_load_work); 1311 1312 return 1; 1313 } 1314 1315 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol, 1316 struct snd_ctl_elem_value *ucontrol) 1317 { 1318 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1319 1320 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type; 1321 1322 return 0; 1323 } 1324 1325 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol, 1326 struct snd_ctl_elem_value *ucontrol) 1327 { 1328 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 1329 1330 if (ucontrol->value.enumerated.item[0] < CS35L41_HDA_NUM_FW) { 1331 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) { 1332 cs35l41->firmware_type = ucontrol->value.enumerated.item[0]; 1333 return 1; 1334 } else { 1335 return 0; 1336 } 1337 } 1338 1339 return -EINVAL; 1340 } 1341 1342 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1343 { 1344 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(cs35l41_hda_fw_ids), cs35l41_hda_fw_ids); 1345 } 1346 1347 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41) 1348 { 1349 char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1350 char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1351 char mute_override_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 1352 struct snd_kcontrol_new fw_type_ctl = { 1353 .name = fw_type_ctl_name, 1354 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1355 .info = cs35l41_fw_type_ctl_info, 1356 .get = cs35l41_fw_type_ctl_get, 1357 .put = cs35l41_fw_type_ctl_put, 1358 }; 1359 struct snd_kcontrol_new fw_load_ctl = { 1360 .name = fw_load_ctl_name, 1361 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1362 .info = snd_ctl_boolean_mono_info, 1363 .get = cs35l41_fw_load_ctl_get, 1364 .put = cs35l41_fw_load_ctl_put, 1365 }; 1366 struct snd_kcontrol_new mute_override_ctl = { 1367 .name = mute_override_ctl_name, 1368 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1369 .info = snd_ctl_boolean_mono_info, 1370 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1371 .get = cs35l41_mute_override_ctl_get, 1372 }; 1373 int ret; 1374 1375 scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type", 1376 cs35l41->amp_name); 1377 scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load", 1378 cs35l41->amp_name); 1379 scnprintf(mute_override_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s Forced Mute Status", 1380 cs35l41->amp_name); 1381 1382 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41)); 1383 if (ret) { 1384 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret); 1385 return ret; 1386 } 1387 1388 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name); 1389 1390 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41)); 1391 if (ret) { 1392 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret); 1393 return ret; 1394 } 1395 1396 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name); 1397 1398 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&mute_override_ctl, cs35l41)); 1399 if (ret) { 1400 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", mute_override_ctl.name, 1401 ret); 1402 return ret; 1403 } 1404 1405 dev_dbg(cs35l41->dev, "Added Control %s\n", mute_override_ctl.name); 1406 1407 return 0; 1408 } 1409 1410 static bool cs35l41_dsm_supported(acpi_handle handle, unsigned int commands) 1411 { 1412 guid_t guid; 1413 1414 guid_parse(CS35L41_UUID, &guid); 1415 1416 return acpi_check_dsm(handle, &guid, 0, BIT(commands)); 1417 } 1418 1419 static int cs35l41_get_acpi_mute_state(struct cs35l41_hda *cs35l41, acpi_handle handle) 1420 { 1421 guid_t guid; 1422 union acpi_object *ret; 1423 int mute = -ENODEV; 1424 1425 guid_parse(CS35L41_UUID, &guid); 1426 1427 if (cs35l41_dsm_supported(handle, CS35L41_DSM_GET_MUTE)) { 1428 ret = acpi_evaluate_dsm(handle, &guid, 0, CS35L41_DSM_GET_MUTE, NULL); 1429 mute = *ret->buffer.pointer; 1430 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute); 1431 } 1432 1433 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute); 1434 1435 return mute; 1436 } 1437 1438 static void cs35l41_acpi_device_notify(acpi_handle handle, u32 event, struct device *dev) 1439 { 1440 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1441 int mute; 1442 1443 if (event != CS35L41_NOTIFY_EVENT) 1444 return; 1445 1446 mute = cs35l41_get_acpi_mute_state(cs35l41, handle); 1447 if (mute < 0) { 1448 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute); 1449 return; 1450 } 1451 1452 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute); 1453 cs35l41->mute_override = (mute > 0); 1454 cs35l41_mute(cs35l41->dev, cs35l41->mute_override); 1455 } 1456 1457 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data) 1458 { 1459 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1460 struct hda_component_parent *parent = master_data; 1461 struct hda_component *comp; 1462 unsigned int sleep_flags; 1463 int ret = 0; 1464 1465 comp = hda_component_from_index(parent, cs35l41->index); 1466 if (!comp) 1467 return -EINVAL; 1468 1469 if (comp->dev) 1470 return -EBUSY; 1471 1472 pm_runtime_get_sync(dev); 1473 1474 mutex_lock(&cs35l41->fw_mutex); 1475 1476 comp->dev = dev; 1477 cs35l41->codec = parent->codec; 1478 if (!cs35l41->acpi_subsystem_id) 1479 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x", 1480 cs35l41->codec->core.subsystem_id); 1481 1482 strscpy(comp->name, dev_name(dev), sizeof(comp->name)); 1483 1484 cs35l41->firmware_type = CS35L41_HDA_FW_SPK_PROT; 1485 1486 if (firmware_autostart) { 1487 dev_dbg(cs35l41->dev, "Firmware Autostart.\n"); 1488 cs35l41->request_fw_load = true; 1489 if (cs35l41_smart_amp(cs35l41) < 0) 1490 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n"); 1491 } else { 1492 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n"); 1493 } 1494 1495 ret = cs35l41_create_controls(cs35l41); 1496 1497 comp->playback_hook = cs35l41_hda_playback_hook; 1498 comp->pre_playback_hook = cs35l41_hda_pre_playback_hook; 1499 comp->post_playback_hook = cs35l41_hda_post_playback_hook; 1500 comp->acpi_notify = cs35l41_acpi_device_notify; 1501 comp->adev = cs35l41->dacpi; 1502 1503 comp->acpi_notifications_supported = cs35l41_dsm_supported(acpi_device_handle(comp->adev), 1504 CS35L41_DSM_GET_MUTE); 1505 1506 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41, 1507 acpi_device_handle(cs35l41->dacpi)) > 0; 1508 1509 mutex_unlock(&cs35l41->fw_mutex); 1510 1511 sleep_flags = lock_system_sleep(); 1512 if (!device_link_add(&cs35l41->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS)) 1513 dev_warn(dev, "Unable to create device link\n"); 1514 unlock_system_sleep(sleep_flags); 1515 1516 pm_runtime_put_autosuspend(dev); 1517 1518 dev_info(cs35l41->dev, 1519 "CS35L41 Bound - SSID: %s, BST: %d, VSPK: %d, CH: %c, FW EN: %d, SPKID: %d\n", 1520 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type, 1521 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH, 1522 channel_name[cs35l41->hw_cfg.spk_pos], 1523 cs35l41->cs_dsp.running, cs35l41->speaker_id); 1524 1525 return ret; 1526 } 1527 1528 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data) 1529 { 1530 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1531 struct hda_component_parent *parent = master_data; 1532 struct hda_component *comp; 1533 unsigned int sleep_flags; 1534 1535 comp = hda_component_from_index(parent, cs35l41->index); 1536 if (!comp) 1537 return; 1538 1539 if (comp->dev == dev) { 1540 sleep_flags = lock_system_sleep(); 1541 device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev); 1542 unlock_system_sleep(sleep_flags); 1543 memset(comp, 0, sizeof(*comp)); 1544 } 1545 } 1546 1547 static const struct component_ops cs35l41_hda_comp_ops = { 1548 .bind = cs35l41_hda_bind, 1549 .unbind = cs35l41_hda_unbind, 1550 }; 1551 1552 static irqreturn_t cs35l41_bst_short_err(int irq, void *data) 1553 { 1554 struct cs35l41_hda *cs35l41 = data; 1555 1556 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n"); 1557 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1558 1559 return IRQ_HANDLED; 1560 } 1561 1562 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data) 1563 { 1564 struct cs35l41_hda *cs35l41 = data; 1565 1566 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n"); 1567 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1568 1569 return IRQ_HANDLED; 1570 } 1571 1572 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data) 1573 { 1574 struct cs35l41_hda *cs35l41 = data; 1575 1576 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n"); 1577 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1578 1579 return IRQ_HANDLED; 1580 } 1581 1582 static irqreturn_t cs35l41_temp_err(int irq, void *data) 1583 { 1584 struct cs35l41_hda *cs35l41 = data; 1585 1586 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n"); 1587 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1588 1589 return IRQ_HANDLED; 1590 } 1591 1592 static irqreturn_t cs35l41_temp_warn(int irq, void *data) 1593 { 1594 struct cs35l41_hda *cs35l41 = data; 1595 1596 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n"); 1597 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1598 1599 return IRQ_HANDLED; 1600 } 1601 1602 static irqreturn_t cs35l41_amp_short(int irq, void *data) 1603 { 1604 struct cs35l41_hda *cs35l41 = data; 1605 1606 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n"); 1607 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1608 1609 return IRQ_HANDLED; 1610 } 1611 1612 static const struct cs35l41_irq cs35l41_irqs[] = { 1613 CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err), 1614 CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err), 1615 CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err), 1616 CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn), 1617 CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err), 1618 CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short), 1619 }; 1620 1621 static const struct regmap_irq cs35l41_reg_irqs[] = { 1622 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR), 1623 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR), 1624 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR), 1625 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN), 1626 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR), 1627 CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR), 1628 }; 1629 1630 static const struct regmap_irq_chip cs35l41_regmap_irq_chip = { 1631 .name = "cs35l41 IRQ1 Controller", 1632 .status_base = CS35L41_IRQ1_STATUS1, 1633 .mask_base = CS35L41_IRQ1_MASK1, 1634 .ack_base = CS35L41_IRQ1_STATUS1, 1635 .num_regs = 4, 1636 .irqs = cs35l41_reg_irqs, 1637 .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs), 1638 .runtime_pm = true, 1639 }; 1640 1641 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol) 1642 { 1643 int irq; 1644 int ret; 1645 int i; 1646 1647 if (!cs35l41->irq) { 1648 dev_warn(cs35l41->dev, "No Interrupt Found"); 1649 goto err; 1650 } 1651 1652 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq, 1653 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1654 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data); 1655 if (ret) { 1656 dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret); 1657 goto err; 1658 } 1659 1660 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) { 1661 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq); 1662 if (irq < 0) { 1663 ret = irq; 1664 dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name, 1665 ret); 1666 goto err; 1667 } 1668 1669 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL, 1670 cs35l41_irqs[i].handler, 1671 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1672 cs35l41_irqs[i].name, cs35l41); 1673 if (ret) { 1674 dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.", 1675 cs35l41_irqs[i].name, ret); 1676 goto err; 1677 } 1678 } 1679 return; 1680 err: 1681 dev_warn(cs35l41->dev, 1682 "IRQ Config Failed. Amp errors may not be recoverable without reboot."); 1683 } 1684 1685 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41) 1686 { 1687 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1688 bool using_irq = false; 1689 int irq_pol; 1690 int ret; 1691 1692 if (!cs35l41->hw_cfg.valid) 1693 return -EINVAL; 1694 1695 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg); 1696 if (ret) 1697 return ret; 1698 1699 if (hw_cfg->gpio1.valid) { 1700 switch (hw_cfg->gpio1.func) { 1701 case CS35L41_NOT_USED: 1702 break; 1703 case CS35l41_VSPK_SWITCH: 1704 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO; 1705 hw_cfg->gpio1.out_en = true; 1706 break; 1707 case CS35l41_SYNC: 1708 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC; 1709 break; 1710 default: 1711 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n", 1712 hw_cfg->gpio1.func); 1713 return -EINVAL; 1714 } 1715 } 1716 1717 if (hw_cfg->gpio2.valid) { 1718 switch (hw_cfg->gpio2.func) { 1719 case CS35L41_NOT_USED: 1720 break; 1721 case CS35L41_INTERRUPT: 1722 using_irq = true; 1723 hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN; 1724 break; 1725 default: 1726 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func); 1727 return -EINVAL; 1728 } 1729 } 1730 1731 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg); 1732 1733 if (using_irq) 1734 cs35l41_configure_interrupt(cs35l41, irq_pol); 1735 1736 return cs35l41_hda_channel_map(cs35l41); 1737 } 1738 1739 int cs35l41_get_speaker_id(struct device *dev, int amp_index, int num_amps, int fixed_gpio_id) 1740 { 1741 struct gpio_desc *speaker_id_desc; 1742 int speaker_id = -ENODEV; 1743 1744 if (fixed_gpio_id >= 0) { 1745 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id); 1746 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN); 1747 if (IS_ERR(speaker_id_desc)) { 1748 speaker_id = PTR_ERR(speaker_id_desc); 1749 return speaker_id; 1750 } 1751 speaker_id = gpiod_get_value_cansleep(speaker_id_desc); 1752 gpiod_put(speaker_id_desc); 1753 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1754 } else { 1755 int base_index; 1756 int gpios_per_amp; 1757 int count; 1758 int tmp; 1759 int i; 1760 1761 count = gpiod_count(dev, "spk-id"); 1762 if (count > 0) { 1763 speaker_id = 0; 1764 gpios_per_amp = count / num_amps; 1765 base_index = gpios_per_amp * amp_index; 1766 1767 if (count % num_amps) 1768 return -EINVAL; 1769 1770 dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp); 1771 1772 for (i = 0; i < gpios_per_amp; i++) { 1773 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index, 1774 GPIOD_IN); 1775 if (IS_ERR(speaker_id_desc)) { 1776 speaker_id = PTR_ERR(speaker_id_desc); 1777 break; 1778 } 1779 tmp = gpiod_get_value_cansleep(speaker_id_desc); 1780 gpiod_put(speaker_id_desc); 1781 if (tmp < 0) { 1782 speaker_id = tmp; 1783 break; 1784 } 1785 speaker_id |= tmp << i; 1786 } 1787 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1788 } 1789 } 1790 return speaker_id; 1791 } 1792 1793 int cs35l41_hda_parse_acpi(struct cs35l41_hda *cs35l41, struct device *physdev, int id) 1794 { 1795 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1796 u32 values[HDA_MAX_COMPONENTS]; 1797 char *property; 1798 size_t nval; 1799 int i, ret; 1800 1801 property = "cirrus,dev-index"; 1802 ret = device_property_count_u32(physdev, property); 1803 if (ret <= 0) 1804 goto err; 1805 1806 if (ret > ARRAY_SIZE(values)) { 1807 ret = -EINVAL; 1808 goto err; 1809 } 1810 nval = ret; 1811 1812 ret = device_property_read_u32_array(physdev, property, values, nval); 1813 if (ret) 1814 goto err; 1815 1816 cs35l41->index = -1; 1817 for (i = 0; i < nval; i++) { 1818 if (values[i] == id) { 1819 cs35l41->index = i; 1820 break; 1821 } 1822 } 1823 if (cs35l41->index == -1) { 1824 dev_err(cs35l41->dev, "No index found in %s\n", property); 1825 ret = -ENODEV; 1826 goto err; 1827 } 1828 1829 /* To use the same release code for all laptop variants we can't use devm_ version of 1830 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node 1831 */ 1832 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(cs35l41->dacpi), "reset", 1833 cs35l41->index, GPIOD_OUT_LOW, 1834 "cs35l41-reset"); 1835 1836 property = "cirrus,speaker-position"; 1837 ret = device_property_read_u32_array(physdev, property, values, nval); 1838 if (ret) 1839 goto err; 1840 hw_cfg->spk_pos = values[cs35l41->index]; 1841 1842 cs35l41->channel_index = 0; 1843 for (i = 0; i < cs35l41->index; i++) 1844 if (values[i] == hw_cfg->spk_pos) 1845 cs35l41->channel_index++; 1846 1847 property = "cirrus,gpio1-func"; 1848 ret = device_property_read_u32_array(physdev, property, values, nval); 1849 if (ret) 1850 goto err; 1851 hw_cfg->gpio1.func = values[cs35l41->index]; 1852 hw_cfg->gpio1.valid = true; 1853 1854 property = "cirrus,gpio2-func"; 1855 ret = device_property_read_u32_array(physdev, property, values, nval); 1856 if (ret) 1857 goto err; 1858 hw_cfg->gpio2.func = values[cs35l41->index]; 1859 hw_cfg->gpio2.valid = true; 1860 1861 property = "cirrus,boost-peak-milliamp"; 1862 ret = device_property_read_u32_array(physdev, property, values, nval); 1863 if (ret == 0) 1864 hw_cfg->bst_ipk = values[cs35l41->index]; 1865 else 1866 hw_cfg->bst_ipk = -1; 1867 1868 property = "cirrus,boost-ind-nanohenry"; 1869 ret = device_property_read_u32_array(physdev, property, values, nval); 1870 if (ret == 0) 1871 hw_cfg->bst_ind = values[cs35l41->index]; 1872 else 1873 hw_cfg->bst_ind = -1; 1874 1875 property = "cirrus,boost-cap-microfarad"; 1876 ret = device_property_read_u32_array(physdev, property, values, nval); 1877 if (ret == 0) 1878 hw_cfg->bst_cap = values[cs35l41->index]; 1879 else 1880 hw_cfg->bst_cap = -1; 1881 1882 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1); 1883 1884 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0) 1885 hw_cfg->bst_type = CS35L41_INT_BOOST; 1886 else 1887 hw_cfg->bst_type = CS35L41_EXT_BOOST; 1888 1889 hw_cfg->valid = true; 1890 1891 return 0; 1892 err: 1893 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret); 1894 hw_cfg->valid = false; 1895 hw_cfg->gpio1.valid = false; 1896 hw_cfg->gpio2.valid = false; 1897 acpi_dev_put(cs35l41->dacpi); 1898 1899 return ret; 1900 } 1901 1902 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id) 1903 { 1904 struct acpi_device *adev; 1905 struct device *physdev; 1906 struct spi_device *spi; 1907 const char *sub; 1908 int ret; 1909 1910 adev = acpi_dev_get_first_match_dev(hid, NULL, -1); 1911 if (!adev) { 1912 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid); 1913 return -ENODEV; 1914 } 1915 1916 cs35l41->dacpi = adev; 1917 physdev = get_device(acpi_get_first_physical_node(adev)); 1918 1919 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev)); 1920 if (IS_ERR(sub)) 1921 sub = NULL; 1922 cs35l41->acpi_subsystem_id = sub; 1923 1924 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid); 1925 if (!ret) { 1926 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n"); 1927 goto out; 1928 } 1929 1930 ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id); 1931 if (ret) { 1932 put_device(physdev); 1933 return ret; 1934 } 1935 out: 1936 put_device(physdev); 1937 1938 cs35l41->bypass_fw = false; 1939 if (cs35l41->control_bus == SPI) { 1940 spi = to_spi_device(cs35l41->dev); 1941 if (spi->max_speed_hz < CS35L41_MAX_ACCEPTABLE_SPI_SPEED_HZ) { 1942 dev_warn(cs35l41->dev, 1943 "SPI speed is too slow to support firmware download: %d Hz.\n", 1944 spi->max_speed_hz); 1945 cs35l41->bypass_fw = true; 1946 } 1947 } 1948 1949 return 0; 1950 } 1951 1952 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq, 1953 struct regmap *regmap, enum control_bus control_bus) 1954 { 1955 unsigned int regid, reg_revid; 1956 struct cs35l41_hda *cs35l41; 1957 int ret; 1958 1959 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs)); 1960 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ); 1961 1962 if (IS_ERR(regmap)) 1963 return PTR_ERR(regmap); 1964 1965 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL); 1966 if (!cs35l41) 1967 return -ENOMEM; 1968 1969 cs35l41->dev = dev; 1970 cs35l41->irq = irq; 1971 cs35l41->regmap = regmap; 1972 cs35l41->control_bus = control_bus; 1973 dev_set_drvdata(dev, cs35l41); 1974 1975 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id); 1976 if (ret) 1977 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n"); 1978 1979 if (IS_ERR(cs35l41->reset_gpio)) { 1980 ret = PTR_ERR(cs35l41->reset_gpio); 1981 cs35l41->reset_gpio = NULL; 1982 if (ret == -EBUSY) { 1983 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n"); 1984 } else { 1985 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n"); 1986 goto err; 1987 } 1988 } 1989 if (cs35l41->reset_gpio) { 1990 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 1991 usleep_range(2000, 2100); 1992 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 1993 } 1994 1995 usleep_range(2000, 2100); 1996 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET); 1997 usleep_range(2000, 2100); 1998 1999 ret = cs35l41_wait_boot_done(cs35l41); 2000 if (ret) 2001 goto err; 2002 2003 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid); 2004 if (ret) 2005 goto err; 2006 2007 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 2008 if (ret) 2009 goto err; 2010 2011 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid); 2012 if (ret) 2013 goto err; 2014 2015 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap); 2016 if (ret) { 2017 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n"); 2018 goto err; 2019 } 2020 2021 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 2022 if (ret) 2023 goto err; 2024 2025 ret = cs35l41_get_calibration(cs35l41); 2026 if (ret && ret != -ENOENT) 2027 goto err; 2028 2029 cs35l41_mute(cs35l41->dev, true); 2030 2031 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work); 2032 mutex_init(&cs35l41->fw_mutex); 2033 2034 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000); 2035 pm_runtime_use_autosuspend(cs35l41->dev); 2036 pm_runtime_set_active(cs35l41->dev); 2037 pm_runtime_get_noresume(cs35l41->dev); 2038 pm_runtime_enable(cs35l41->dev); 2039 2040 ret = cs35l41_hda_apply_properties(cs35l41); 2041 if (ret) 2042 goto err_pm; 2043 2044 pm_runtime_put_autosuspend(cs35l41->dev); 2045 2046 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops); 2047 if (ret) { 2048 dev_err_probe(cs35l41->dev, ret, "Register component failed\n"); 2049 goto err_pm; 2050 } 2051 2052 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid); 2053 2054 return 0; 2055 2056 err_pm: 2057 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2058 pm_runtime_disable(cs35l41->dev); 2059 pm_runtime_put_noidle(cs35l41->dev); 2060 2061 err: 2062 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2063 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2064 gpiod_put(cs35l41->reset_gpio); 2065 gpiod_put(cs35l41->cs_gpio); 2066 acpi_dev_put(cs35l41->dacpi); 2067 kfree(cs35l41->acpi_subsystem_id); 2068 2069 return ret; 2070 } 2071 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, "SND_HDA_SCODEC_CS35L41"); 2072 2073 void cs35l41_hda_remove(struct device *dev) 2074 { 2075 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 2076 2077 component_del(cs35l41->dev, &cs35l41_hda_comp_ops); 2078 2079 pm_runtime_get_sync(cs35l41->dev); 2080 pm_runtime_dont_use_autosuspend(cs35l41->dev); 2081 pm_runtime_disable(cs35l41->dev); 2082 2083 if (cs35l41->halo_initialized) 2084 cs35l41_remove_dsp(cs35l41); 2085 2086 acpi_dev_put(cs35l41->dacpi); 2087 2088 pm_runtime_put_noidle(cs35l41->dev); 2089 2090 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 2091 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 2092 gpiod_put(cs35l41->reset_gpio); 2093 gpiod_put(cs35l41->cs_gpio); 2094 kfree(cs35l41->acpi_subsystem_id); 2095 } 2096 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, "SND_HDA_SCODEC_CS35L41"); 2097 2098 const struct dev_pm_ops cs35l41_hda_pm_ops = { 2099 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, 2100 cs35l41_runtime_idle) 2101 .prepare = cs35l41_system_suspend_prep, 2102 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume) 2103 }; 2104 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, "SND_HDA_SCODEC_CS35L41"); 2105 2106 MODULE_DESCRIPTION("CS35L41 HDA Driver"); 2107 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB"); 2108 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>"); 2109 MODULE_LICENSE("GPL"); 2110 MODULE_IMPORT_NS("FW_CS_DSP"); 2111 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw"); 2112 MODULE_FIRMWARE("cirrus/cs35l41-*.bin"); 2113