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 "hda_local.h" 16 #include "hda_auto_parser.h" 17 #include "hda_jack.h" 18 #include "hda_generic.h" 19 #include "hda_component.h" 20 #include "cs35l41_hda.h" 21 #include "hda_cs_dsp_ctl.h" 22 23 #define CS35L41_FIRMWARE_ROOT "cirrus/" 24 #define CS35L41_PART "cs35l41" 25 26 #define HALO_STATE_DSP_CTL_NAME "HALO_STATE" 27 #define HALO_STATE_DSP_CTL_TYPE 5 28 #define HALO_STATE_DSP_CTL_ALG 262308 29 #define CAL_R_DSP_CTL_NAME "CAL_R" 30 #define CAL_STATUS_DSP_CTL_NAME "CAL_STATUS" 31 #define CAL_CHECKSUM_DSP_CTL_NAME "CAL_CHECKSUM" 32 #define CAL_AMBIENT_DSP_CTL_NAME "CAL_AMBIENT" 33 #define CAL_DSP_CTL_TYPE 5 34 #define CAL_DSP_CTL_ALG 205 35 36 static bool firmware_autostart = 1; 37 module_param(firmware_autostart, bool, 0444); 38 MODULE_PARM_DESC(firmware_autostart, "Allow automatic firmware download on boot" 39 "(0=Disable, 1=Enable) (default=1); "); 40 41 static const struct reg_sequence cs35l41_hda_config[] = { 42 { CS35L41_PLL_CLK_CTRL, 0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1 43 { CS35L41_DSP_CLK_CTRL, 0x00000003 }, // DSP CLK EN 44 { CS35L41_GLOBAL_CLK_CTRL, 0x00000003 }, // GLOBAL_FS = 48 kHz 45 { CS35L41_SP_ENABLES, 0x00010000 }, // ASP_RX1_EN = 1 46 { CS35L41_SP_RATE_CTRL, 0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz 47 { CS35L41_SP_FORMAT, 0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer 48 { CS35L41_SP_HIZ_CTRL, 0x00000002 }, // Hi-Z unused 49 { CS35L41_SP_TX_WL, 0x00000018 }, // 24 cycles/slot 50 { CS35L41_SP_RX_WL, 0x00000018 }, // 24 cycles/slot 51 { CS35L41_DAC_PCM1_SRC, 0x00000008 }, // DACPCM1_SRC = ASPRX1 52 { CS35L41_ASP_TX1_SRC, 0x00000018 }, // ASPTX1 SRC = VMON 53 { CS35L41_ASP_TX2_SRC, 0x00000019 }, // ASPTX2 SRC = IMON 54 { CS35L41_ASP_TX3_SRC, 0x00000032 }, // ASPTX3 SRC = ERRVOL 55 { CS35L41_ASP_TX4_SRC, 0x00000033 }, // ASPTX4 SRC = CLASSH_TGT 56 { CS35L41_DSP1_RX1_SRC, 0x00000008 }, // DSP1RX1 SRC = ASPRX1 57 { CS35L41_DSP1_RX2_SRC, 0x00000009 }, // DSP1RX2 SRC = ASPRX2 58 { CS35L41_DSP1_RX3_SRC, 0x00000018 }, // DSP1RX3 SRC = VMON 59 { CS35L41_DSP1_RX4_SRC, 0x00000019 }, // DSP1RX4 SRC = IMON 60 { CS35L41_DSP1_RX5_SRC, 0x00000020 }, // DSP1RX5 SRC = ERRVOL 61 { CS35L41_AMP_DIG_VOL_CTRL, 0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM 0.0 dB 62 { CS35L41_AMP_GAIN_CTRL, 0x00000084 }, // AMP_GAIN_PCM 4.5 dB 63 }; 64 65 static const struct reg_sequence cs35l41_hda_config_dsp[] = { 66 { CS35L41_PLL_CLK_CTRL, 0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1 67 { CS35L41_DSP_CLK_CTRL, 0x00000003 }, // DSP CLK EN 68 { CS35L41_GLOBAL_CLK_CTRL, 0x00000003 }, // GLOBAL_FS = 48 kHz 69 { CS35L41_SP_ENABLES, 0x00010001 }, // ASP_RX1_EN = 1, ASP_TX1_EN = 1 70 { CS35L41_SP_RATE_CTRL, 0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz 71 { CS35L41_SP_FORMAT, 0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer 72 { CS35L41_SP_HIZ_CTRL, 0x00000003 }, // Hi-Z unused/disabled 73 { CS35L41_SP_TX_WL, 0x00000018 }, // 24 cycles/slot 74 { CS35L41_SP_RX_WL, 0x00000018 }, // 24 cycles/slot 75 { CS35L41_DAC_PCM1_SRC, 0x00000032 }, // DACPCM1_SRC = ERR_VOL 76 { CS35L41_ASP_TX1_SRC, 0x00000018 }, // ASPTX1 SRC = VMON 77 { CS35L41_ASP_TX2_SRC, 0x00000019 }, // ASPTX2 SRC = IMON 78 { CS35L41_ASP_TX3_SRC, 0x00000028 }, // ASPTX3 SRC = VPMON 79 { CS35L41_ASP_TX4_SRC, 0x00000029 }, // ASPTX4 SRC = VBSTMON 80 { CS35L41_DSP1_RX1_SRC, 0x00000008 }, // DSP1RX1 SRC = ASPRX1 81 { CS35L41_DSP1_RX2_SRC, 0x00000008 }, // DSP1RX2 SRC = ASPRX1 82 { CS35L41_DSP1_RX3_SRC, 0x00000018 }, // DSP1RX3 SRC = VMON 83 { CS35L41_DSP1_RX4_SRC, 0x00000019 }, // DSP1RX4 SRC = IMON 84 { CS35L41_DSP1_RX5_SRC, 0x00000029 }, // DSP1RX5 SRC = VBSTMON 85 { CS35L41_AMP_DIG_VOL_CTRL, 0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM 0.0 dB 86 { CS35L41_AMP_GAIN_CTRL, 0x00000233 }, // AMP_GAIN_PCM = 17.5dB AMP_GAIN_PDM = 19.5dB 87 }; 88 89 static const struct reg_sequence cs35l41_hda_mute[] = { 90 { CS35L41_AMP_GAIN_CTRL, 0x00000000 }, // AMP_GAIN_PCM 0.5 dB 91 { CS35L41_AMP_DIG_VOL_CTRL, 0x0000A678 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM Mute 92 }; 93 94 static void cs35l41_add_controls(struct cs35l41_hda *cs35l41) 95 { 96 struct hda_cs_dsp_ctl_info info; 97 98 info.device_name = cs35l41->amp_name; 99 info.fw_type = cs35l41->firmware_type; 100 info.card = cs35l41->codec->card; 101 102 hda_cs_dsp_add_controls(&cs35l41->cs_dsp, &info); 103 } 104 105 static const struct cs_dsp_client_ops client_ops = { 106 .control_remove = hda_cs_dsp_control_remove, 107 }; 108 109 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41, 110 const struct firmware **firmware, char **filename, 111 const char *dir, const char *ssid, const char *amp_name, 112 int spkid, const char *filetype) 113 { 114 const char * const dsp_name = cs35l41->cs_dsp.name; 115 char *s, c; 116 int ret = 0; 117 118 if (spkid > -1 && ssid && amp_name) 119 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d-%s.%s", dir, CS35L41_PART, 120 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type], 121 ssid, spkid, amp_name, filetype); 122 else if (spkid > -1 && ssid) 123 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d.%s", dir, CS35L41_PART, 124 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type], 125 ssid, spkid, filetype); 126 else if (ssid && amp_name) 127 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-%s.%s", dir, CS35L41_PART, 128 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type], 129 ssid, amp_name, filetype); 130 else if (ssid) 131 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s.%s", dir, CS35L41_PART, 132 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type], 133 ssid, filetype); 134 else 135 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s.%s", dir, CS35L41_PART, 136 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type], 137 filetype); 138 139 if (*filename == NULL) 140 return -ENOMEM; 141 142 /* 143 * Make sure that filename is lower-case and any non alpha-numeric 144 * characters except full stop and '/' are replaced with hyphens. 145 */ 146 s = *filename; 147 while (*s) { 148 c = *s; 149 if (isalnum(c)) 150 *s = tolower(c); 151 else if (c != '.' && c != '/') 152 *s = '-'; 153 s++; 154 } 155 156 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev); 157 if (ret != 0) { 158 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename); 159 kfree(*filename); 160 *filename = NULL; 161 } 162 163 return ret; 164 } 165 166 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41, 167 const struct firmware **wmfw_firmware, 168 char **wmfw_filename, 169 const struct firmware **coeff_firmware, 170 char **coeff_filename) 171 { 172 int ret; 173 174 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.wmfw */ 175 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 176 CS35L41_FIRMWARE_ROOT, 177 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 178 cs35l41->speaker_id, "wmfw"); 179 if (!ret) { 180 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 181 return cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 182 CS35L41_FIRMWARE_ROOT, 183 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 184 cs35l41->speaker_id, "bin"); 185 } 186 187 /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */ 188 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 189 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id, 190 cs35l41->amp_name, -1, "wmfw"); 191 if (!ret) { 192 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 193 return cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 194 CS35L41_FIRMWARE_ROOT, 195 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 196 cs35l41->speaker_id, "bin"); 197 } 198 199 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */ 200 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 201 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id, 202 NULL, cs35l41->speaker_id, "wmfw"); 203 if (!ret) { 204 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 205 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 206 CS35L41_FIRMWARE_ROOT, 207 cs35l41->acpi_subsystem_id, 208 cs35l41->amp_name, cs35l41->speaker_id, "bin"); 209 if (ret) 210 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */ 211 return cs35l41_request_firmware_file(cs35l41, coeff_firmware, 212 coeff_filename, CS35L41_FIRMWARE_ROOT, 213 cs35l41->acpi_subsystem_id, NULL, 214 cs35l41->speaker_id, "bin"); 215 } 216 217 /* try cirrus/part-dspN-fwtype-sub.wmfw */ 218 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 219 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id, 220 NULL, -1, "wmfw"); 221 if (!ret) { 222 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */ 223 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 224 CS35L41_FIRMWARE_ROOT, 225 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 226 cs35l41->speaker_id, "bin"); 227 if (ret) 228 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */ 229 return cs35l41_request_firmware_file(cs35l41, coeff_firmware, 230 coeff_filename, CS35L41_FIRMWARE_ROOT, 231 cs35l41->acpi_subsystem_id, NULL, 232 cs35l41->speaker_id, "bin"); 233 } 234 235 return ret; 236 } 237 238 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41, 239 const struct firmware **wmfw_firmware, 240 char **wmfw_filename, 241 const struct firmware **coeff_firmware, 242 char **coeff_filename) 243 { 244 int ret; 245 246 if (cs35l41->speaker_id > -1) { 247 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename, 248 coeff_firmware, coeff_filename); 249 goto out; 250 251 } 252 253 /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */ 254 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 255 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id, 256 cs35l41->amp_name, -1, "wmfw"); 257 if (!ret) { 258 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */ 259 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 260 CS35L41_FIRMWARE_ROOT, 261 cs35l41->acpi_subsystem_id, cs35l41->amp_name, 262 -1, "bin"); 263 goto out; 264 } 265 266 /* try cirrus/part-dspN-fwtype-sub.wmfw */ 267 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 268 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id, 269 NULL, -1, "wmfw"); 270 if (!ret) { 271 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */ 272 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 273 CS35L41_FIRMWARE_ROOT, 274 cs35l41->acpi_subsystem_id, 275 cs35l41->amp_name, -1, "bin"); 276 if (ret) 277 /* try cirrus/part-dspN-fwtype-sub.bin */ 278 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 279 CS35L41_FIRMWARE_ROOT, 280 cs35l41->acpi_subsystem_id, NULL, -1, 281 "bin"); 282 } 283 284 out: 285 if (!ret) 286 return 0; 287 288 /* Handle fallback */ 289 dev_warn(cs35l41->dev, "Falling back to default firmware.\n"); 290 291 release_firmware(*wmfw_firmware); 292 kfree(*wmfw_filename); 293 294 /* fallback try cirrus/part-dspN-fwtype.wmfw */ 295 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename, 296 CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw"); 297 if (!ret) 298 /* fallback try cirrus/part-dspN-fwtype.bin */ 299 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename, 300 CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin"); 301 302 if (ret) { 303 release_firmware(*wmfw_firmware); 304 kfree(*wmfw_filename); 305 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n"); 306 } 307 return ret; 308 } 309 310 #if IS_ENABLED(CONFIG_EFI) 311 static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, __be32 ambient, __be32 r0, 312 __be32 status, __be32 checksum) 313 { 314 int ret; 315 316 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE, 317 CAL_DSP_CTL_ALG, &ambient, 4); 318 if (ret) { 319 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME, 320 ret); 321 return ret; 322 } 323 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE, 324 CAL_DSP_CTL_ALG, &r0, 4); 325 if (ret) { 326 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret); 327 return ret; 328 } 329 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE, 330 CAL_DSP_CTL_ALG, &status, 4); 331 if (ret) { 332 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME, 333 ret); 334 return ret; 335 } 336 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE, 337 CAL_DSP_CTL_ALG, &checksum, 4); 338 if (ret) { 339 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME, 340 ret); 341 return ret; 342 } 343 344 return 0; 345 } 346 347 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41) 348 { 349 static efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe, 350 0x5a, 0xa3, 0x5d, 0xb3); 351 static efi_char16_t efi_name[] = L"CirrusSmartAmpCalibrationData"; 352 const struct cs35l41_amp_efi_data *efi_data; 353 const struct cs35l41_amp_cal_data *cl; 354 unsigned long data_size = 0; 355 efi_status_t status; 356 int ret = 0; 357 u8 *data = NULL; 358 u32 attr; 359 360 /* Get real size of UEFI variable */ 361 status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data); 362 if (status == EFI_BUFFER_TOO_SMALL) { 363 ret = -ENODEV; 364 /* Allocate data buffer of data_size bytes */ 365 data = vmalloc(data_size); 366 if (!data) 367 return -ENOMEM; 368 /* Get variable contents into buffer */ 369 status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data); 370 if (status == EFI_SUCCESS) { 371 efi_data = (struct cs35l41_amp_efi_data *)data; 372 dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n", 373 efi_data->size, efi_data->count); 374 if (efi_data->count > cs35l41->index) { 375 cl = &efi_data->data[cs35l41->index]; 376 dev_dbg(cs35l41->dev, 377 "Calibration: Ambient=%02x, Status=%02x, R0=%d\n", 378 cl->calAmbient, cl->calStatus, cl->calR); 379 380 /* Calibration can only be applied whilst the DSP is not running */ 381 ret = cs35l41_apply_calibration(cs35l41, 382 cpu_to_be32(cl->calAmbient), 383 cpu_to_be32(cl->calR), 384 cpu_to_be32(cl->calStatus), 385 cpu_to_be32(cl->calR + 1)); 386 } 387 } 388 vfree(data); 389 } 390 return ret; 391 } 392 #else 393 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41) 394 { 395 dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n"); 396 return 0; 397 } 398 #endif 399 400 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41) 401 { 402 const struct firmware *coeff_firmware = NULL; 403 const struct firmware *wmfw_firmware = NULL; 404 struct cs_dsp *dsp = &cs35l41->cs_dsp; 405 char *coeff_filename = NULL; 406 char *wmfw_filename = NULL; 407 int ret; 408 409 if (!cs35l41->halo_initialized) { 410 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp); 411 dsp->client_ops = &client_ops; 412 413 ret = cs_dsp_halo_init(&cs35l41->cs_dsp); 414 if (ret) 415 return ret; 416 cs35l41->halo_initialized = true; 417 } 418 419 ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename, 420 &coeff_firmware, &coeff_filename); 421 if (ret < 0) 422 return ret; 423 424 dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename); 425 if (coeff_filename) 426 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename); 427 else 428 dev_warn(cs35l41->dev, "No Coefficient File available.\n"); 429 430 ret = cs_dsp_power_up(dsp, wmfw_firmware, wmfw_filename, coeff_firmware, coeff_filename, 431 hda_cs_dsp_fw_ids[cs35l41->firmware_type]); 432 if (ret) 433 goto err_release; 434 435 cs35l41_add_controls(cs35l41); 436 437 ret = cs35l41_save_calibration(cs35l41); 438 439 err_release: 440 release_firmware(wmfw_firmware); 441 release_firmware(coeff_firmware); 442 kfree(wmfw_filename); 443 kfree(coeff_filename); 444 445 return ret; 446 } 447 448 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41) 449 { 450 struct cs_dsp *dsp = &cs35l41->cs_dsp; 451 452 cs_dsp_stop(dsp); 453 cs_dsp_power_down(dsp); 454 cs35l41->firmware_running = false; 455 dev_dbg(cs35l41->dev, "Unloaded Firmware\n"); 456 } 457 458 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41) 459 { 460 struct cs_dsp *dsp = &cs35l41->cs_dsp; 461 462 cancel_work_sync(&cs35l41->fw_load_work); 463 464 mutex_lock(&cs35l41->fw_mutex); 465 cs35l41_shutdown_dsp(cs35l41); 466 cs_dsp_remove(dsp); 467 cs35l41->halo_initialized = false; 468 mutex_unlock(&cs35l41->fw_mutex); 469 } 470 471 /* Protection release cycle to get the speaker out of Safe-Mode */ 472 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask) 473 { 474 regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0); 475 regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask); 476 regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask); 477 } 478 479 /* Clear all errors to release safe mode. Global Enable must be cleared first. */ 480 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41) 481 { 482 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors); 483 cs35l41->irq_errors = 0; 484 } 485 486 static void cs35l41_hda_playback_hook(struct device *dev, int action) 487 { 488 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 489 struct regmap *reg = cs35l41->regmap; 490 int ret = 0; 491 492 switch (action) { 493 case HDA_GEN_PCM_ACT_OPEN: 494 pm_runtime_get_sync(dev); 495 mutex_lock(&cs35l41->fw_mutex); 496 cs35l41->playback_started = true; 497 if (cs35l41->firmware_running) { 498 regmap_multi_reg_write(reg, cs35l41_hda_config_dsp, 499 ARRAY_SIZE(cs35l41_hda_config_dsp)); 500 regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2, 501 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 502 1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT); 503 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, 504 CSPL_MBOX_CMD_RESUME); 505 } else { 506 regmap_multi_reg_write(reg, cs35l41_hda_config, 507 ARRAY_SIZE(cs35l41_hda_config)); 508 } 509 ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2, 510 CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT); 511 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 512 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001); 513 mutex_unlock(&cs35l41->fw_mutex); 514 break; 515 case HDA_GEN_PCM_ACT_PREPARE: 516 mutex_lock(&cs35l41->fw_mutex); 517 ret = cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL, 518 cs35l41->firmware_running); 519 mutex_unlock(&cs35l41->fw_mutex); 520 break; 521 case HDA_GEN_PCM_ACT_CLEANUP: 522 mutex_lock(&cs35l41->fw_mutex); 523 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute)); 524 ret = cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, NULL, 525 cs35l41->firmware_running); 526 mutex_unlock(&cs35l41->fw_mutex); 527 break; 528 case HDA_GEN_PCM_ACT_CLOSE: 529 mutex_lock(&cs35l41->fw_mutex); 530 ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2, 531 CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT); 532 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 533 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001); 534 if (cs35l41->firmware_running) { 535 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, 536 CSPL_MBOX_CMD_PAUSE); 537 regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2, 538 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 539 0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT); 540 } 541 cs35l41_irq_release(cs35l41); 542 cs35l41->playback_started = false; 543 mutex_unlock(&cs35l41->fw_mutex); 544 545 pm_runtime_mark_last_busy(dev); 546 pm_runtime_put_autosuspend(dev); 547 break; 548 default: 549 dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action); 550 break; 551 } 552 553 if (ret) 554 dev_err(cs35l41->dev, "Regmap access fail: %d\n", ret); 555 } 556 557 static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot, 558 unsigned int rx_num, unsigned int *rx_slot) 559 { 560 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 561 static const char * const channel_name[] = { "L", "R" }; 562 563 if (!cs35l41->amp_name) { 564 if (*rx_slot >= ARRAY_SIZE(channel_name)) 565 return -EINVAL; 566 567 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d", 568 channel_name[*rx_slot], cs35l41->channel_index); 569 if (!cs35l41->amp_name) 570 return -ENOMEM; 571 } 572 573 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num, 574 rx_slot); 575 } 576 577 static void cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41) 578 { 579 mutex_lock(&cs35l41->fw_mutex); 580 if (cs35l41->firmware_running) { 581 582 regcache_cache_only(cs35l41->regmap, false); 583 584 cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap); 585 cs35l41_shutdown_dsp(cs35l41); 586 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type); 587 588 regcache_cache_only(cs35l41->regmap, true); 589 regcache_mark_dirty(cs35l41->regmap); 590 } 591 mutex_unlock(&cs35l41->fw_mutex); 592 } 593 594 static int cs35l41_system_suspend(struct device *dev) 595 { 596 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 597 int ret; 598 599 dev_dbg(cs35l41->dev, "System Suspend\n"); 600 601 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 602 dev_err_once(cs35l41->dev, "System Suspend not supported\n"); 603 return 0; /* don't block the whole system suspend */ 604 } 605 606 ret = pm_runtime_force_suspend(dev); 607 if (ret) 608 return ret; 609 610 /* Shutdown DSP before system suspend */ 611 cs35l41_ready_for_reset(cs35l41); 612 613 /* 614 * Reset GPIO may be shared, so cannot reset here. 615 * However beyond this point, amps may be powered down. 616 */ 617 return 0; 618 } 619 620 static int cs35l41_system_resume(struct device *dev) 621 { 622 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 623 int ret; 624 625 dev_dbg(cs35l41->dev, "System Resume\n"); 626 627 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 628 dev_err_once(cs35l41->dev, "System Resume not supported\n"); 629 return 0; /* don't block the whole system resume */ 630 } 631 632 if (cs35l41->reset_gpio) { 633 usleep_range(2000, 2100); 634 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 635 } 636 637 usleep_range(2000, 2100); 638 639 ret = pm_runtime_force_resume(dev); 640 641 mutex_lock(&cs35l41->fw_mutex); 642 if (!ret && cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) { 643 cs35l41->fw_request_ongoing = true; 644 schedule_work(&cs35l41->fw_load_work); 645 } 646 mutex_unlock(&cs35l41->fw_mutex); 647 648 return ret; 649 } 650 651 static int cs35l41_runtime_idle(struct device *dev) 652 { 653 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 654 655 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) 656 return -EBUSY; /* suspend not supported yet on this model */ 657 return 0; 658 } 659 660 static int cs35l41_runtime_suspend(struct device *dev) 661 { 662 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 663 int ret = 0; 664 665 dev_dbg(cs35l41->dev, "Runtime Suspend\n"); 666 667 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 668 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n"); 669 return 0; 670 } 671 672 mutex_lock(&cs35l41->fw_mutex); 673 674 if (cs35l41->playback_started) { 675 regmap_multi_reg_write(cs35l41->regmap, cs35l41_hda_mute, 676 ARRAY_SIZE(cs35l41_hda_mute)); 677 cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type, 0, 678 NULL, cs35l41->firmware_running); 679 regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2, 680 CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT); 681 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 682 regmap_write(cs35l41->regmap, CS35L41_GPIO1_CTRL1, 0x00000001); 683 regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2, 684 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK, 685 0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT); 686 cs35l41->playback_started = false; 687 } 688 689 if (cs35l41->firmware_running) { 690 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap, 691 cs35l41->hw_cfg.bst_type); 692 if (ret) 693 goto err; 694 } else { 695 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type); 696 } 697 698 regcache_cache_only(cs35l41->regmap, true); 699 regcache_mark_dirty(cs35l41->regmap); 700 701 err: 702 mutex_unlock(&cs35l41->fw_mutex); 703 704 return ret; 705 } 706 707 static int cs35l41_runtime_resume(struct device *dev) 708 { 709 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 710 int ret = 0; 711 712 dev_dbg(cs35l41->dev, "Runtime Resume\n"); 713 714 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) { 715 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n"); 716 return 0; 717 } 718 719 mutex_lock(&cs35l41->fw_mutex); 720 721 regcache_cache_only(cs35l41->regmap, false); 722 723 if (cs35l41->firmware_running) { 724 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap); 725 if (ret) { 726 dev_warn(cs35l41->dev, "Unable to exit Hibernate."); 727 goto err; 728 } 729 } 730 731 /* Test key needs to be unlocked to allow the OTP settings to re-apply */ 732 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 733 ret = regcache_sync(cs35l41->regmap); 734 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 735 if (ret) { 736 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret); 737 goto err; 738 } 739 740 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 741 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg); 742 743 err: 744 mutex_unlock(&cs35l41->fw_mutex); 745 746 return ret; 747 } 748 749 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41) 750 { 751 __be32 halo_sts; 752 int ret; 753 754 ret = cs35l41_init_dsp(cs35l41); 755 if (ret) { 756 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret); 757 goto clean_dsp; 758 } 759 760 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap); 761 if (ret) { 762 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret); 763 goto clean_dsp; 764 } 765 766 ret = cs_dsp_run(&cs35l41->cs_dsp); 767 if (ret) { 768 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret); 769 goto clean_dsp; 770 } 771 772 ret = read_poll_timeout(hda_cs_dsp_read_ctl, ret, 773 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN, 774 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME, 775 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG, 776 &halo_sts, sizeof(halo_sts)); 777 778 if (ret) { 779 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n", 780 halo_sts); 781 goto clean_dsp; 782 } 783 784 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE); 785 if (ret) { 786 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret); 787 goto clean_dsp; 788 } 789 790 cs35l41->firmware_running = true; 791 792 return 0; 793 794 clean_dsp: 795 cs35l41_shutdown_dsp(cs35l41); 796 return ret; 797 } 798 799 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load) 800 { 801 if (cs35l41->firmware_running && !load) { 802 dev_dbg(cs35l41->dev, "Unloading Firmware\n"); 803 cs35l41_shutdown_dsp(cs35l41); 804 } else if (!cs35l41->firmware_running && load) { 805 dev_dbg(cs35l41->dev, "Loading Firmware\n"); 806 cs35l41_smart_amp(cs35l41); 807 } else { 808 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n"); 809 } 810 } 811 812 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol, 813 struct snd_ctl_elem_value *ucontrol) 814 { 815 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 816 817 ucontrol->value.integer.value[0] = cs35l41->request_fw_load; 818 return 0; 819 } 820 821 static void cs35l41_fw_load_work(struct work_struct *work) 822 { 823 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work); 824 825 pm_runtime_get_sync(cs35l41->dev); 826 827 mutex_lock(&cs35l41->fw_mutex); 828 829 /* Recheck if playback is ongoing, mutex will block playback during firmware loading */ 830 if (cs35l41->playback_started) 831 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n"); 832 else 833 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load); 834 835 cs35l41->fw_request_ongoing = false; 836 mutex_unlock(&cs35l41->fw_mutex); 837 838 pm_runtime_mark_last_busy(cs35l41->dev); 839 pm_runtime_put_autosuspend(cs35l41->dev); 840 } 841 842 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol, 843 struct snd_ctl_elem_value *ucontrol) 844 { 845 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 846 847 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0]) 848 return 0; 849 850 if (cs35l41->fw_request_ongoing) { 851 dev_dbg(cs35l41->dev, "Existing request not complete\n"); 852 return -EBUSY; 853 } 854 855 /* Check if playback is ongoing when initial request is made */ 856 if (cs35l41->playback_started) { 857 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n"); 858 return -EBUSY; 859 } 860 861 cs35l41->fw_request_ongoing = true; 862 cs35l41->request_fw_load = ucontrol->value.integer.value[0]; 863 schedule_work(&cs35l41->fw_load_work); 864 865 return 1; 866 } 867 868 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol, 869 struct snd_ctl_elem_value *ucontrol) 870 { 871 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 872 873 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type; 874 875 return 0; 876 } 877 878 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol, 879 struct snd_ctl_elem_value *ucontrol) 880 { 881 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol); 882 883 if (ucontrol->value.enumerated.item[0] < HDA_CS_DSP_NUM_FW) { 884 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) { 885 cs35l41->firmware_type = ucontrol->value.enumerated.item[0]; 886 return 1; 887 } else { 888 return 0; 889 } 890 } 891 892 return -EINVAL; 893 } 894 895 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 896 { 897 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(hda_cs_dsp_fw_ids), hda_cs_dsp_fw_ids); 898 } 899 900 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41) 901 { 902 char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 903 char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 904 struct snd_kcontrol_new fw_type_ctl = { 905 .name = fw_type_ctl_name, 906 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 907 .info = cs35l41_fw_type_ctl_info, 908 .get = cs35l41_fw_type_ctl_get, 909 .put = cs35l41_fw_type_ctl_put, 910 }; 911 struct snd_kcontrol_new fw_load_ctl = { 912 .name = fw_load_ctl_name, 913 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 914 .info = snd_ctl_boolean_mono_info, 915 .get = cs35l41_fw_load_ctl_get, 916 .put = cs35l41_fw_load_ctl_put, 917 }; 918 int ret; 919 920 scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type", 921 cs35l41->amp_name); 922 scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load", 923 cs35l41->amp_name); 924 925 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41)); 926 if (ret) { 927 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret); 928 return ret; 929 } 930 931 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name); 932 933 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41)); 934 if (ret) { 935 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret); 936 return ret; 937 } 938 939 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name); 940 941 return 0; 942 } 943 944 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data) 945 { 946 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 947 struct hda_component *comps = master_data; 948 int ret = 0; 949 950 if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS) 951 return -EINVAL; 952 953 comps = &comps[cs35l41->index]; 954 if (comps->dev) 955 return -EBUSY; 956 957 pm_runtime_get_sync(dev); 958 959 mutex_lock(&cs35l41->fw_mutex); 960 961 comps->dev = dev; 962 if (!cs35l41->acpi_subsystem_id) 963 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x", 964 comps->codec->core.subsystem_id); 965 cs35l41->codec = comps->codec; 966 strscpy(comps->name, dev_name(dev), sizeof(comps->name)); 967 968 cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT; 969 970 if (firmware_autostart) { 971 dev_dbg(cs35l41->dev, "Firmware Autostart.\n"); 972 cs35l41->request_fw_load = true; 973 if (cs35l41_smart_amp(cs35l41) < 0) 974 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n"); 975 } else { 976 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n"); 977 } 978 979 ret = cs35l41_create_controls(cs35l41); 980 981 comps->playback_hook = cs35l41_hda_playback_hook; 982 983 mutex_unlock(&cs35l41->fw_mutex); 984 985 pm_runtime_mark_last_busy(dev); 986 pm_runtime_put_autosuspend(dev); 987 988 return ret; 989 } 990 991 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data) 992 { 993 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 994 struct hda_component *comps = master_data; 995 996 if (comps[cs35l41->index].dev == dev) 997 memset(&comps[cs35l41->index], 0, sizeof(*comps)); 998 } 999 1000 static const struct component_ops cs35l41_hda_comp_ops = { 1001 .bind = cs35l41_hda_bind, 1002 .unbind = cs35l41_hda_unbind, 1003 }; 1004 1005 static irqreturn_t cs35l41_bst_short_err(int irq, void *data) 1006 { 1007 struct cs35l41_hda *cs35l41 = data; 1008 1009 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n"); 1010 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1011 1012 return IRQ_HANDLED; 1013 } 1014 1015 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data) 1016 { 1017 struct cs35l41_hda *cs35l41 = data; 1018 1019 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n"); 1020 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1021 1022 return IRQ_HANDLED; 1023 } 1024 1025 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data) 1026 { 1027 struct cs35l41_hda *cs35l41 = data; 1028 1029 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n"); 1030 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1031 1032 return IRQ_HANDLED; 1033 } 1034 1035 static irqreturn_t cs35l41_temp_err(int irq, void *data) 1036 { 1037 struct cs35l41_hda *cs35l41 = data; 1038 1039 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n"); 1040 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1041 1042 return IRQ_HANDLED; 1043 } 1044 1045 static irqreturn_t cs35l41_temp_warn(int irq, void *data) 1046 { 1047 struct cs35l41_hda *cs35l41 = data; 1048 1049 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n"); 1050 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1051 1052 return IRQ_HANDLED; 1053 } 1054 1055 static irqreturn_t cs35l41_amp_short(int irq, void *data) 1056 { 1057 struct cs35l41_hda *cs35l41 = data; 1058 1059 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n"); 1060 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors); 1061 1062 return IRQ_HANDLED; 1063 } 1064 1065 static const struct cs35l41_irq cs35l41_irqs[] = { 1066 CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err), 1067 CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err), 1068 CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err), 1069 CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn), 1070 CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err), 1071 CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short), 1072 }; 1073 1074 static const struct regmap_irq cs35l41_reg_irqs[] = { 1075 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR), 1076 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR), 1077 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR), 1078 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN), 1079 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR), 1080 CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR), 1081 }; 1082 1083 static struct regmap_irq_chip cs35l41_regmap_irq_chip = { 1084 .name = "cs35l41 IRQ1 Controller", 1085 .status_base = CS35L41_IRQ1_STATUS1, 1086 .mask_base = CS35L41_IRQ1_MASK1, 1087 .ack_base = CS35L41_IRQ1_STATUS1, 1088 .num_regs = 4, 1089 .irqs = cs35l41_reg_irqs, 1090 .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs), 1091 .runtime_pm = true, 1092 }; 1093 1094 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41) 1095 { 1096 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1097 bool using_irq = false; 1098 int irq, irq_pol; 1099 int ret; 1100 int i; 1101 1102 if (!cs35l41->hw_cfg.valid) 1103 return -EINVAL; 1104 1105 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg); 1106 if (ret) 1107 return ret; 1108 1109 if (hw_cfg->gpio1.valid) { 1110 switch (hw_cfg->gpio1.func) { 1111 case CS35L41_NOT_USED: 1112 break; 1113 case CS35l41_VSPK_SWITCH: 1114 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO; 1115 hw_cfg->gpio1.out_en = true; 1116 break; 1117 case CS35l41_SYNC: 1118 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC; 1119 break; 1120 default: 1121 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n", 1122 hw_cfg->gpio1.func); 1123 return -EINVAL; 1124 } 1125 } 1126 1127 if (hw_cfg->gpio2.valid) { 1128 switch (hw_cfg->gpio2.func) { 1129 case CS35L41_NOT_USED: 1130 break; 1131 case CS35L41_INTERRUPT: 1132 using_irq = true; 1133 hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN; 1134 break; 1135 default: 1136 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func); 1137 return -EINVAL; 1138 } 1139 } 1140 1141 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg); 1142 1143 if (cs35l41->irq && using_irq) { 1144 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq, 1145 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1146 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data); 1147 if (ret) 1148 return ret; 1149 1150 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) { 1151 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq); 1152 if (irq < 0) 1153 return irq; 1154 1155 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL, 1156 cs35l41_irqs[i].handler, 1157 IRQF_ONESHOT | IRQF_SHARED | irq_pol, 1158 cs35l41_irqs[i].name, cs35l41); 1159 if (ret) 1160 return ret; 1161 } 1162 } 1163 1164 return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos); 1165 } 1166 1167 static int cs35l41_get_speaker_id(struct device *dev, int amp_index, 1168 int num_amps, int fixed_gpio_id) 1169 { 1170 struct gpio_desc *speaker_id_desc; 1171 int speaker_id = -ENODEV; 1172 1173 if (fixed_gpio_id >= 0) { 1174 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id); 1175 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN); 1176 if (IS_ERR(speaker_id_desc)) { 1177 speaker_id = PTR_ERR(speaker_id_desc); 1178 return speaker_id; 1179 } 1180 speaker_id = gpiod_get_value_cansleep(speaker_id_desc); 1181 gpiod_put(speaker_id_desc); 1182 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1183 } else { 1184 int base_index; 1185 int gpios_per_amp; 1186 int count; 1187 int tmp; 1188 int i; 1189 1190 count = gpiod_count(dev, "spk-id"); 1191 if (count > 0) { 1192 speaker_id = 0; 1193 gpios_per_amp = count / num_amps; 1194 base_index = gpios_per_amp * amp_index; 1195 1196 if (count % num_amps) 1197 return -EINVAL; 1198 1199 dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp); 1200 1201 for (i = 0; i < gpios_per_amp; i++) { 1202 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index, 1203 GPIOD_IN); 1204 if (IS_ERR(speaker_id_desc)) { 1205 speaker_id = PTR_ERR(speaker_id_desc); 1206 break; 1207 } 1208 tmp = gpiod_get_value_cansleep(speaker_id_desc); 1209 gpiod_put(speaker_id_desc); 1210 if (tmp < 0) { 1211 speaker_id = tmp; 1212 break; 1213 } 1214 speaker_id |= tmp << i; 1215 } 1216 dev_dbg(dev, "Speaker ID = %d\n", speaker_id); 1217 } 1218 } 1219 return speaker_id; 1220 } 1221 1222 /* 1223 * Device CLSA010(0/1) doesn't have _DSD so a gpiod_get by the label reset won't work. 1224 * And devices created by serial-multi-instantiate don't have their device struct 1225 * pointing to the correct fwnode, so acpi_dev must be used here. 1226 * And devm functions expect that the device requesting the resource has the correct 1227 * fwnode. 1228 */ 1229 static int cs35l41_no_acpi_dsd(struct cs35l41_hda *cs35l41, struct device *physdev, int id, 1230 const char *hid) 1231 { 1232 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1233 1234 /* check I2C address to assign the index */ 1235 cs35l41->index = id == 0x40 ? 0 : 1; 1236 cs35l41->channel_index = 0; 1237 cs35l41->reset_gpio = gpiod_get_index(physdev, NULL, 0, GPIOD_OUT_HIGH); 1238 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, 0, 0, 2); 1239 hw_cfg->spk_pos = cs35l41->index; 1240 hw_cfg->gpio2.func = CS35L41_INTERRUPT; 1241 hw_cfg->gpio2.valid = true; 1242 hw_cfg->valid = true; 1243 1244 if (strncmp(hid, "CLSA0100", 8) == 0) { 1245 hw_cfg->bst_type = CS35L41_EXT_BOOST_NO_VSPK_SWITCH; 1246 } else if (strncmp(hid, "CLSA0101", 8) == 0) { 1247 hw_cfg->bst_type = CS35L41_EXT_BOOST; 1248 hw_cfg->gpio1.func = CS35l41_VSPK_SWITCH; 1249 hw_cfg->gpio1.valid = true; 1250 } else { 1251 /* 1252 * Note: CLSA010(0/1) are special cases which use a slightly different design. 1253 * All other HIDs e.g. CSC3551 require valid ACPI _DSD properties to be supported. 1254 */ 1255 dev_err(cs35l41->dev, "Error: ACPI _DSD Properties are missing for HID %s.\n", hid); 1256 hw_cfg->valid = false; 1257 hw_cfg->gpio1.valid = false; 1258 hw_cfg->gpio2.valid = false; 1259 return -EINVAL; 1260 } 1261 1262 return 0; 1263 } 1264 1265 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id) 1266 { 1267 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 1268 u32 values[HDA_MAX_COMPONENTS]; 1269 struct acpi_device *adev; 1270 struct device *physdev; 1271 const char *sub; 1272 char *property; 1273 size_t nval; 1274 int i, ret; 1275 1276 adev = acpi_dev_get_first_match_dev(hid, NULL, -1); 1277 if (!adev) { 1278 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid); 1279 return -ENODEV; 1280 } 1281 1282 physdev = get_device(acpi_get_first_physical_node(adev)); 1283 acpi_dev_put(adev); 1284 1285 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev)); 1286 if (IS_ERR(sub)) 1287 sub = NULL; 1288 cs35l41->acpi_subsystem_id = sub; 1289 1290 property = "cirrus,dev-index"; 1291 ret = device_property_count_u32(physdev, property); 1292 if (ret <= 0) { 1293 ret = cs35l41_no_acpi_dsd(cs35l41, physdev, id, hid); 1294 goto err_put_physdev; 1295 } 1296 if (ret > ARRAY_SIZE(values)) { 1297 ret = -EINVAL; 1298 goto err; 1299 } 1300 nval = ret; 1301 1302 ret = device_property_read_u32_array(physdev, property, values, nval); 1303 if (ret) 1304 goto err; 1305 1306 cs35l41->index = -1; 1307 for (i = 0; i < nval; i++) { 1308 if (values[i] == id) { 1309 cs35l41->index = i; 1310 break; 1311 } 1312 } 1313 if (cs35l41->index == -1) { 1314 dev_err(cs35l41->dev, "No index found in %s\n", property); 1315 ret = -ENODEV; 1316 goto err; 1317 } 1318 1319 /* To use the same release code for all laptop variants we can't use devm_ version of 1320 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node 1321 */ 1322 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index, 1323 GPIOD_OUT_LOW, "cs35l41-reset"); 1324 1325 property = "cirrus,speaker-position"; 1326 ret = device_property_read_u32_array(physdev, property, values, nval); 1327 if (ret) 1328 goto err; 1329 hw_cfg->spk_pos = values[cs35l41->index]; 1330 1331 cs35l41->channel_index = 0; 1332 for (i = 0; i < cs35l41->index; i++) 1333 if (values[i] == hw_cfg->spk_pos) 1334 cs35l41->channel_index++; 1335 1336 property = "cirrus,gpio1-func"; 1337 ret = device_property_read_u32_array(physdev, property, values, nval); 1338 if (ret) 1339 goto err; 1340 hw_cfg->gpio1.func = values[cs35l41->index]; 1341 hw_cfg->gpio1.valid = true; 1342 1343 property = "cirrus,gpio2-func"; 1344 ret = device_property_read_u32_array(physdev, property, values, nval); 1345 if (ret) 1346 goto err; 1347 hw_cfg->gpio2.func = values[cs35l41->index]; 1348 hw_cfg->gpio2.valid = true; 1349 1350 property = "cirrus,boost-peak-milliamp"; 1351 ret = device_property_read_u32_array(physdev, property, values, nval); 1352 if (ret == 0) 1353 hw_cfg->bst_ipk = values[cs35l41->index]; 1354 else 1355 hw_cfg->bst_ipk = -1; 1356 1357 property = "cirrus,boost-ind-nanohenry"; 1358 ret = device_property_read_u32_array(physdev, property, values, nval); 1359 if (ret == 0) 1360 hw_cfg->bst_ind = values[cs35l41->index]; 1361 else 1362 hw_cfg->bst_ind = -1; 1363 1364 property = "cirrus,boost-cap-microfarad"; 1365 ret = device_property_read_u32_array(physdev, property, values, nval); 1366 if (ret == 0) 1367 hw_cfg->bst_cap = values[cs35l41->index]; 1368 else 1369 hw_cfg->bst_cap = -1; 1370 1371 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1); 1372 1373 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0) 1374 hw_cfg->bst_type = CS35L41_INT_BOOST; 1375 else 1376 hw_cfg->bst_type = CS35L41_EXT_BOOST; 1377 1378 hw_cfg->valid = true; 1379 put_device(physdev); 1380 1381 return 0; 1382 1383 err: 1384 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret); 1385 err_put_physdev: 1386 put_device(physdev); 1387 1388 return ret; 1389 } 1390 1391 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq, 1392 struct regmap *regmap) 1393 { 1394 unsigned int int_sts, regid, reg_revid, mtl_revid, chipid, int_status; 1395 struct cs35l41_hda *cs35l41; 1396 int ret; 1397 1398 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs)); 1399 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ); 1400 1401 if (IS_ERR(regmap)) 1402 return PTR_ERR(regmap); 1403 1404 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL); 1405 if (!cs35l41) 1406 return -ENOMEM; 1407 1408 cs35l41->dev = dev; 1409 cs35l41->irq = irq; 1410 cs35l41->regmap = regmap; 1411 dev_set_drvdata(dev, cs35l41); 1412 1413 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id); 1414 if (ret) 1415 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n"); 1416 1417 if (IS_ERR(cs35l41->reset_gpio)) { 1418 ret = PTR_ERR(cs35l41->reset_gpio); 1419 cs35l41->reset_gpio = NULL; 1420 if (ret == -EBUSY) { 1421 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n"); 1422 } else { 1423 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n"); 1424 goto err; 1425 } 1426 } 1427 if (cs35l41->reset_gpio) { 1428 usleep_range(2000, 2100); 1429 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 1430 } 1431 1432 usleep_range(2000, 2100); 1433 1434 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status, 1435 int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000); 1436 if (ret) { 1437 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret); 1438 goto err; 1439 } 1440 1441 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts); 1442 if (ret || (int_sts & CS35L41_OTP_BOOT_ERR)) { 1443 dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n", 1444 int_sts & CS35L41_OTP_BOOT_ERR, ret); 1445 ret = -EIO; 1446 goto err; 1447 } 1448 1449 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, ®id); 1450 if (ret) { 1451 dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret); 1452 goto err; 1453 } 1454 1455 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, ®_revid); 1456 if (ret) { 1457 dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret); 1458 goto err; 1459 } 1460 1461 mtl_revid = reg_revid & CS35L41_MTLREVID_MASK; 1462 1463 chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID; 1464 if (regid != chipid) { 1465 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", regid, chipid); 1466 ret = -ENODEV; 1467 goto err; 1468 } 1469 1470 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 1471 if (ret) 1472 goto err; 1473 1474 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid); 1475 if (ret) 1476 goto err; 1477 1478 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap); 1479 if (ret) { 1480 dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret); 1481 goto err; 1482 } 1483 1484 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 1485 if (ret) 1486 goto err; 1487 1488 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work); 1489 mutex_init(&cs35l41->fw_mutex); 1490 1491 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000); 1492 pm_runtime_use_autosuspend(cs35l41->dev); 1493 pm_runtime_mark_last_busy(cs35l41->dev); 1494 pm_runtime_set_active(cs35l41->dev); 1495 pm_runtime_get_noresume(cs35l41->dev); 1496 pm_runtime_enable(cs35l41->dev); 1497 1498 ret = cs35l41_hda_apply_properties(cs35l41); 1499 if (ret) 1500 goto err_pm; 1501 1502 pm_runtime_put_autosuspend(cs35l41->dev); 1503 1504 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops); 1505 if (ret) { 1506 dev_err(cs35l41->dev, "Register component failed: %d\n", ret); 1507 pm_runtime_disable(cs35l41->dev); 1508 goto err; 1509 } 1510 1511 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid); 1512 1513 return 0; 1514 1515 err_pm: 1516 pm_runtime_disable(cs35l41->dev); 1517 pm_runtime_put_noidle(cs35l41->dev); 1518 1519 err: 1520 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 1521 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 1522 gpiod_put(cs35l41->reset_gpio); 1523 kfree(cs35l41->acpi_subsystem_id); 1524 1525 return ret; 1526 } 1527 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, SND_HDA_SCODEC_CS35L41); 1528 1529 void cs35l41_hda_remove(struct device *dev) 1530 { 1531 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 1532 1533 pm_runtime_get_sync(cs35l41->dev); 1534 pm_runtime_disable(cs35l41->dev); 1535 1536 if (cs35l41->halo_initialized) 1537 cs35l41_remove_dsp(cs35l41); 1538 1539 component_del(cs35l41->dev, &cs35l41_hda_comp_ops); 1540 1541 pm_runtime_put_noidle(cs35l41->dev); 1542 1543 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type)) 1544 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 1545 gpiod_put(cs35l41->reset_gpio); 1546 kfree(cs35l41->acpi_subsystem_id); 1547 } 1548 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41); 1549 1550 const struct dev_pm_ops cs35l41_hda_pm_ops = { 1551 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, 1552 cs35l41_runtime_idle) 1553 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume) 1554 }; 1555 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41); 1556 1557 MODULE_DESCRIPTION("CS35L41 HDA Driver"); 1558 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS); 1559 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>"); 1560 MODULE_LICENSE("GPL"); 1561 MODULE_IMPORT_NS(FW_CS_DSP); 1562