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