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