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