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