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