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