1 // SPDX-License-Identifier: GPL-2.0
3 // CS35l41 ALSA HDA audio driver
5 // Copyright 2021 Cirrus Logic, Inc.
7 // Author: Lucas Tanure <tanureal@opensource.cirrus.com>
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"
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"
24 #define CS35L41_FIRMWARE_ROOT "cirrus/"
25 #define CS35L41_PART "cs35l41"
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
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); ");
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
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
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
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
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
104 static void cs35l41_add_controls(struct cs35l41_hda *cs35l41)
106 struct hda_cs_dsp_ctl_info info;
108 info.device_name = cs35l41->amp_name;
109 info.fw_type = cs35l41->firmware_type;
110 info.card = cs35l41->codec->card;
112 hda_cs_dsp_add_controls(&cs35l41->cs_dsp, &info);
115 static const struct cs_dsp_client_ops client_ops = {
116 .control_remove = hda_cs_dsp_control_remove,
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)
124 const char * const dsp_name = cs35l41->cs_dsp.name;
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, "/*(DEBLOBBED)*/", dir, CS35L41_PART,
138 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
139 ssid, amp_name, filetype);
141 *filename = kasprintf(GFP_KERNEL, "/*(DEBLOBBED)*/", dir, CS35L41_PART,
142 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
145 *filename = kasprintf(GFP_KERNEL, "/*(DEBLOBBED)*/", dir, CS35L41_PART,
146 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
149 if (*filename == NULL)
153 * Make sure that filename is lower-case and any non alpha-numeric
154 * characters except full stop and '/' are replaced with hyphens.
161 else if (c != '.' && c != '/')
166 ret = firmware_reject_nowarn(firmware, *filename, cs35l41->dev);
168 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
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)
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");
190 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
191 ret = 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");
201 /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
202 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
203 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
204 cs35l41->amp_name, -1, "wmfw");
206 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
207 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
208 CS35L41_FIRMWARE_ROOT,
209 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
210 cs35l41->speaker_id, "bin");
217 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */
218 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
219 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
220 NULL, cs35l41->speaker_id, "wmfw");
222 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
223 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
224 CS35L41_FIRMWARE_ROOT,
225 cs35l41->acpi_subsystem_id,
226 cs35l41->amp_name, cs35l41->speaker_id, "bin");
228 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
229 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
230 coeff_filename, CS35L41_FIRMWARE_ROOT,
231 cs35l41->acpi_subsystem_id, NULL,
232 cs35l41->speaker_id, "bin");
239 /* try cirrus/part-dspN-fwtype-sub.wmfw */
240 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
241 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
244 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
245 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
246 CS35L41_FIRMWARE_ROOT,
247 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
248 cs35l41->speaker_id, "bin");
250 /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
251 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
252 coeff_filename, CS35L41_FIRMWARE_ROOT,
253 cs35l41->acpi_subsystem_id, NULL,
254 cs35l41->speaker_id, "bin");
261 release_firmware(*wmfw_firmware);
262 kfree(*wmfw_filename);
266 static int cs35l41_fallback_firmware_file(struct cs35l41_hda *cs35l41,
267 const struct firmware **wmfw_firmware,
268 char **wmfw_filename,
269 const struct firmware **coeff_firmware,
270 char **coeff_filename)
274 /* Handle fallback */
275 dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
277 /* fallback try cirrus/part-dspN-fwtype.wmfw */
278 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
279 CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
283 /* fallback try cirrus/part-dspN-fwtype.bin */
284 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
285 CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
287 release_firmware(*wmfw_firmware);
288 kfree(*wmfw_filename);
294 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
298 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
299 const struct firmware **wmfw_firmware,
300 char **wmfw_filename,
301 const struct firmware **coeff_firmware,
302 char **coeff_filename)
306 if (cs35l41->speaker_id > -1) {
307 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
308 coeff_firmware, coeff_filename);
312 /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
313 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
314 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
315 cs35l41->amp_name, -1, "wmfw");
317 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
318 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
319 CS35L41_FIRMWARE_ROOT,
320 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
328 /* try cirrus/part-dspN-fwtype-sub.wmfw */
329 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
330 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
333 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
334 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
335 CS35L41_FIRMWARE_ROOT,
336 cs35l41->acpi_subsystem_id,
337 cs35l41->amp_name, -1, "bin");
339 /* try cirrus/part-dspN-fwtype-sub.bin */
340 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
341 CS35L41_FIRMWARE_ROOT,
342 cs35l41->acpi_subsystem_id, NULL, -1,
350 /* if all attempts at finding firmware fail, try fallback */
356 release_firmware(*wmfw_firmware);
357 kfree(*wmfw_filename);
359 return cs35l41_fallback_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
360 coeff_firmware, coeff_filename);
363 #if IS_ENABLED(CONFIG_EFI)
364 static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, __be32 ambient, __be32 r0,
365 __be32 status, __be32 checksum)
369 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
370 CAL_DSP_CTL_ALG, &ambient, 4);
372 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME,
376 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
377 CAL_DSP_CTL_ALG, &r0, 4);
379 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret);
382 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
383 CAL_DSP_CTL_ALG, &status, 4);
385 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
389 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
390 CAL_DSP_CTL_ALG, &checksum, 4);
392 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME,
400 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
402 static efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe,
403 0x5a, 0xa3, 0x5d, 0xb3);
404 static efi_char16_t efi_name[] = L"CirrusSmartAmpCalibrationData";
405 const struct cs35l41_amp_efi_data *efi_data;
406 const struct cs35l41_amp_cal_data *cl;
407 unsigned long data_size = 0;
413 /* Get real size of UEFI variable */
414 status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
415 if (status == EFI_BUFFER_TOO_SMALL) {
417 /* Allocate data buffer of data_size bytes */
418 data = vmalloc(data_size);
421 /* Get variable contents into buffer */
422 status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
423 if (status == EFI_SUCCESS) {
424 efi_data = (struct cs35l41_amp_efi_data *)data;
425 dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n",
426 efi_data->size, efi_data->count);
427 if (efi_data->count > cs35l41->index) {
428 cl = &efi_data->data[cs35l41->index];
429 dev_dbg(cs35l41->dev,
430 "Calibration: Ambient=%02x, Status=%02x, R0=%d\n",
431 cl->calAmbient, cl->calStatus, cl->calR);
433 /* Calibration can only be applied whilst the DSP is not running */
434 ret = cs35l41_apply_calibration(cs35l41,
435 cpu_to_be32(cl->calAmbient),
436 cpu_to_be32(cl->calR),
437 cpu_to_be32(cl->calStatus),
438 cpu_to_be32(cl->calR + 1));
446 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
448 dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n");
453 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
455 const struct firmware *coeff_firmware = NULL;
456 const struct firmware *wmfw_firmware = NULL;
457 struct cs_dsp *dsp = &cs35l41->cs_dsp;
458 char *coeff_filename = NULL;
459 char *wmfw_filename = NULL;
462 if (!cs35l41->halo_initialized) {
463 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
464 dsp->client_ops = &client_ops;
466 ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
469 cs35l41->halo_initialized = true;
472 ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
473 &coeff_firmware, &coeff_filename);
477 dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
479 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
481 dev_warn(cs35l41->dev, "No Coefficient File available.\n");
483 ret = cs_dsp_power_up(dsp, wmfw_firmware, wmfw_filename, coeff_firmware, coeff_filename,
484 hda_cs_dsp_fw_ids[cs35l41->firmware_type]);
488 cs35l41_add_controls(cs35l41);
490 ret = cs35l41_save_calibration(cs35l41);
493 release_firmware(wmfw_firmware);
494 release_firmware(coeff_firmware);
495 kfree(wmfw_filename);
496 kfree(coeff_filename);
501 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
503 struct cs_dsp *dsp = &cs35l41->cs_dsp;
506 cs_dsp_power_down(dsp);
507 dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
510 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
512 struct cs_dsp *dsp = &cs35l41->cs_dsp;
514 cancel_work_sync(&cs35l41->fw_load_work);
516 mutex_lock(&cs35l41->fw_mutex);
517 cs35l41_shutdown_dsp(cs35l41);
519 cs35l41->halo_initialized = false;
520 mutex_unlock(&cs35l41->fw_mutex);
523 /* Protection release cycle to get the speaker out of Safe-Mode */
524 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask)
526 regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0);
527 regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
528 regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
531 /* Clear all errors to release safe mode. Global Enable must be cleared first. */
532 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
534 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
535 cs35l41->irq_errors = 0;
538 static void cs35l41_hda_play_start(struct device *dev)
540 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
541 struct regmap *reg = cs35l41->regmap;
543 dev_dbg(dev, "Play (Start)\n");
545 if (cs35l41->playback_started) {
546 dev_dbg(dev, "Playback already started.");
550 cs35l41->playback_started = true;
552 if (cs35l41->cs_dsp.running) {
553 regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
554 ARRAY_SIZE(cs35l41_hda_config_dsp));
555 regmap_update_bits(reg, CS35L41_PWR_CTRL2,
556 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
557 1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
558 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
560 regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config));
562 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
563 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
564 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
568 static void cs35l41_mute(struct device *dev, bool mute)
570 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
571 struct regmap *reg = cs35l41->regmap;
573 dev_dbg(dev, "Mute(%d:%d) Playback Started: %d\n", mute, cs35l41->mute_override,
574 cs35l41->playback_started);
576 if (cs35l41->playback_started) {
577 if (mute || cs35l41->mute_override) {
578 dev_dbg(dev, "Muting\n");
579 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
581 dev_dbg(dev, "Unmuting\n");
582 if (cs35l41->cs_dsp.running) {
583 regmap_multi_reg_write(reg, cs35l41_hda_unmute_dsp,
584 ARRAY_SIZE(cs35l41_hda_unmute_dsp));
586 regmap_multi_reg_write(reg, cs35l41_hda_unmute,
587 ARRAY_SIZE(cs35l41_hda_unmute));
593 static void cs35l41_hda_play_done(struct device *dev)
595 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
596 struct regmap *reg = cs35l41->regmap;
598 dev_dbg(dev, "Play (Complete)\n");
600 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1,
602 cs35l41_mute(dev, false);
605 static void cs35l41_hda_pause_start(struct device *dev)
607 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
608 struct regmap *reg = cs35l41->regmap;
610 dev_dbg(dev, "Pause (Start)\n");
612 cs35l41_mute(dev, true);
613 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0,
617 static void cs35l41_hda_pause_done(struct device *dev)
619 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
620 struct regmap *reg = cs35l41->regmap;
622 dev_dbg(dev, "Pause (Complete)\n");
624 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
625 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
626 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
627 if (cs35l41->cs_dsp.running) {
628 cs35l41_set_cspl_mbox_cmd(dev, reg, CSPL_MBOX_CMD_PAUSE);
629 regmap_update_bits(reg, CS35L41_PWR_CTRL2,
630 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
631 0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
633 cs35l41_irq_release(cs35l41);
634 cs35l41->playback_started = false;
637 static void cs35l41_hda_pre_playback_hook(struct device *dev, int action)
639 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
642 case HDA_GEN_PCM_ACT_CLEANUP:
643 mutex_lock(&cs35l41->fw_mutex);
644 cs35l41_hda_pause_start(dev);
645 mutex_unlock(&cs35l41->fw_mutex);
651 static void cs35l41_hda_playback_hook(struct device *dev, int action)
653 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
656 case HDA_GEN_PCM_ACT_OPEN:
658 * All amps must be resumed before we can start playing back.
659 * This ensures, for external boost, that all amps are in AMP_SAFE mode.
660 * Do this in HDA_GEN_PCM_ACT_OPEN, since this is run prior to any of the
663 pm_runtime_get_sync(dev);
665 case HDA_GEN_PCM_ACT_PREPARE:
666 mutex_lock(&cs35l41->fw_mutex);
667 cs35l41_hda_play_start(dev);
668 mutex_unlock(&cs35l41->fw_mutex);
670 case HDA_GEN_PCM_ACT_CLEANUP:
671 mutex_lock(&cs35l41->fw_mutex);
672 cs35l41_hda_pause_done(dev);
673 mutex_unlock(&cs35l41->fw_mutex);
675 case HDA_GEN_PCM_ACT_CLOSE:
676 mutex_lock(&cs35l41->fw_mutex);
677 if (!cs35l41->cs_dsp.running && cs35l41->request_fw_load &&
678 !cs35l41->fw_request_ongoing) {
679 dev_info(dev, "Requesting Firmware Load after HDA_GEN_PCM_ACT_CLOSE\n");
680 cs35l41->fw_request_ongoing = true;
681 schedule_work(&cs35l41->fw_load_work);
683 mutex_unlock(&cs35l41->fw_mutex);
686 * Playback must be finished for all amps before we start runtime suspend.
687 * This ensures no amps are playing back when we start putting them to sleep.
689 pm_runtime_mark_last_busy(dev);
690 pm_runtime_put_autosuspend(dev);
697 static void cs35l41_hda_post_playback_hook(struct device *dev, int action)
699 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
702 case HDA_GEN_PCM_ACT_PREPARE:
703 mutex_lock(&cs35l41->fw_mutex);
704 cs35l41_hda_play_done(dev);
705 mutex_unlock(&cs35l41->fw_mutex);
712 static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot,
713 unsigned int rx_num, unsigned int *rx_slot)
715 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
716 static const char * const channel_name[] = { "L", "R" };
718 if (!cs35l41->amp_name) {
719 if (*rx_slot >= ARRAY_SIZE(channel_name))
722 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d",
723 channel_name[*rx_slot], cs35l41->channel_index);
724 if (!cs35l41->amp_name)
728 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
732 static int cs35l41_verify_id(struct cs35l41_hda *cs35l41, unsigned int *regid, unsigned int *reg_revid)
734 unsigned int mtl_revid, chipid;
737 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, regid);
739 dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n");
743 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, reg_revid);
745 dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n");
749 mtl_revid = *reg_revid & CS35L41_MTLREVID_MASK;
751 chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID;
752 if (*regid != chipid) {
753 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", *regid, chipid);
760 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
762 mutex_lock(&cs35l41->fw_mutex);
763 if (cs35l41->cs_dsp.running) {
764 cs35l41->cs_dsp.running = false;
765 cs35l41->cs_dsp.booted = false;
767 regcache_mark_dirty(cs35l41->regmap);
768 mutex_unlock(&cs35l41->fw_mutex);
773 static int cs35l41_system_suspend_prep(struct device *dev)
775 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
777 dev_dbg(cs35l41->dev, "System Suspend Prepare\n");
779 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
780 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
781 return 0; /* don't block the whole system suspend */
784 mutex_lock(&cs35l41->fw_mutex);
785 if (cs35l41->playback_started)
786 cs35l41_hda_pause_start(dev);
787 mutex_unlock(&cs35l41->fw_mutex);
792 static int cs35l41_system_suspend(struct device *dev)
794 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
797 dev_dbg(cs35l41->dev, "System Suspend\n");
799 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
800 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
801 return 0; /* don't block the whole system suspend */
804 mutex_lock(&cs35l41->fw_mutex);
805 if (cs35l41->playback_started)
806 cs35l41_hda_pause_done(dev);
807 mutex_unlock(&cs35l41->fw_mutex);
809 ret = pm_runtime_force_suspend(dev);
811 dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret);
815 /* Shutdown DSP before system suspend */
816 ret = cs35l41_ready_for_reset(cs35l41);
818 dev_err(dev, "System Suspend Failed, not ready for Reset: %d\n", ret);
820 if (cs35l41->reset_gpio) {
821 dev_info(cs35l41->dev, "Asserting Reset\n");
822 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
823 usleep_range(2000, 2100);
826 dev_dbg(cs35l41->dev, "System Suspended\n");
831 static int cs35l41_wait_boot_done(struct cs35l41_hda *cs35l41)
833 unsigned int int_status;
836 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
837 int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000);
839 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE\n");
843 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_status);
844 if (ret || (int_status & CS35L41_OTP_BOOT_ERR)) {
845 dev_err(cs35l41->dev, "OTP Boot status %x error\n",
846 int_status & CS35L41_OTP_BOOT_ERR);
855 static int cs35l41_system_resume(struct device *dev)
857 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
860 dev_dbg(cs35l41->dev, "System Resume\n");
862 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
863 dev_err_once(cs35l41->dev, "System Resume not supported\n");
864 return 0; /* don't block the whole system resume */
867 if (cs35l41->reset_gpio) {
868 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
869 usleep_range(2000, 2100);
870 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
873 usleep_range(2000, 2100);
875 regcache_cache_only(cs35l41->regmap, false);
877 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
878 usleep_range(2000, 2100);
880 ret = cs35l41_wait_boot_done(cs35l41);
884 regcache_cache_only(cs35l41->regmap, true);
886 ret = pm_runtime_force_resume(dev);
888 dev_err(dev, "System Resume Failed: Unable to runtime resume: %d\n", ret);
892 mutex_lock(&cs35l41->fw_mutex);
894 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
895 cs35l41->fw_request_ongoing = true;
896 schedule_work(&cs35l41->fw_load_work);
898 mutex_unlock(&cs35l41->fw_mutex);
903 static int cs35l41_runtime_idle(struct device *dev)
905 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
907 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH)
908 return -EBUSY; /* suspend not supported yet on this model */
912 static int cs35l41_runtime_suspend(struct device *dev)
914 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
917 dev_dbg(cs35l41->dev, "Runtime Suspend\n");
919 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
920 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n");
924 mutex_lock(&cs35l41->fw_mutex);
926 if (cs35l41->cs_dsp.running) {
927 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
928 cs35l41->hw_cfg.bst_type);
932 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
935 regcache_cache_only(cs35l41->regmap, true);
936 regcache_mark_dirty(cs35l41->regmap);
939 mutex_unlock(&cs35l41->fw_mutex);
944 static int cs35l41_runtime_resume(struct device *dev)
946 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
947 unsigned int regid, reg_revid;
950 dev_dbg(cs35l41->dev, "Runtime Resume\n");
952 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
953 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n");
957 mutex_lock(&cs35l41->fw_mutex);
959 regcache_cache_only(cs35l41->regmap, false);
961 if (cs35l41->cs_dsp.running) {
962 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
964 dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
969 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
973 /* Test key needs to be unlocked to allow the OTP settings to re-apply */
974 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
975 ret = regcache_sync(cs35l41->regmap);
976 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
978 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
982 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
983 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
985 dev_dbg(cs35l41->dev, "CS35L41 Resumed (%x), Revision: %02X\n", regid, reg_revid);
988 mutex_unlock(&cs35l41->fw_mutex);
993 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
995 unsigned int fw_status;
999 ret = cs35l41_init_dsp(cs35l41);
1001 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
1005 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
1007 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
1011 ret = cs_dsp_run(&cs35l41->cs_dsp);
1013 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
1017 ret = read_poll_timeout(hda_cs_dsp_read_ctl, ret,
1018 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN,
1019 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
1020 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG,
1021 &halo_sts, sizeof(halo_sts));
1024 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n",
1029 ret = regmap_read(cs35l41->regmap, CS35L41_DSP_MBOX_2, &fw_status);
1031 dev_err(cs35l41->dev,
1032 "Failed to read firmware status: %d\n", ret);
1036 switch (fw_status) {
1037 case CSPL_MBOX_STS_RUNNING:
1038 case CSPL_MBOX_STS_PAUSED:
1041 dev_err(cs35l41->dev, "Firmware status is invalid: %u\n",
1047 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
1049 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
1056 cs35l41_shutdown_dsp(cs35l41);
1060 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
1062 if (cs35l41->cs_dsp.running && !load) {
1063 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
1064 cs35l41_shutdown_dsp(cs35l41);
1065 } else if (!cs35l41->cs_dsp.running && load) {
1066 dev_dbg(cs35l41->dev, "Loading Firmware\n");
1067 cs35l41_smart_amp(cs35l41);
1069 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
1073 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol,
1074 struct snd_ctl_elem_value *ucontrol)
1076 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1078 ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
1082 static int cs35l41_mute_override_ctl_get(struct snd_kcontrol *kcontrol,
1083 struct snd_ctl_elem_value *ucontrol)
1085 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1087 ucontrol->value.integer.value[0] = cs35l41->mute_override;
1091 static void cs35l41_fw_load_work(struct work_struct *work)
1093 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
1095 pm_runtime_get_sync(cs35l41->dev);
1097 mutex_lock(&cs35l41->fw_mutex);
1099 /* Recheck if playback is ongoing, mutex will block playback during firmware loading */
1100 if (cs35l41->playback_started)
1101 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n");
1103 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
1105 cs35l41->fw_request_ongoing = false;
1106 mutex_unlock(&cs35l41->fw_mutex);
1108 pm_runtime_mark_last_busy(cs35l41->dev);
1109 pm_runtime_put_autosuspend(cs35l41->dev);
1112 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol,
1113 struct snd_ctl_elem_value *ucontrol)
1115 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1117 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
1120 if (cs35l41->fw_request_ongoing) {
1121 dev_dbg(cs35l41->dev, "Existing request not complete\n");
1125 /* Check if playback is ongoing when initial request is made */
1126 if (cs35l41->playback_started) {
1127 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
1131 cs35l41->fw_request_ongoing = true;
1132 cs35l41->request_fw_load = ucontrol->value.integer.value[0];
1133 schedule_work(&cs35l41->fw_load_work);
1138 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol,
1139 struct snd_ctl_elem_value *ucontrol)
1141 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1143 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
1148 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol,
1149 struct snd_ctl_elem_value *ucontrol)
1151 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1153 if (ucontrol->value.enumerated.item[0] < HDA_CS_DSP_NUM_FW) {
1154 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) {
1155 cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
1165 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1167 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(hda_cs_dsp_fw_ids), hda_cs_dsp_fw_ids);
1170 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
1172 char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1173 char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1174 char mute_override_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1175 struct snd_kcontrol_new fw_type_ctl = {
1176 .name = fw_type_ctl_name,
1177 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1178 .info = cs35l41_fw_type_ctl_info,
1179 .get = cs35l41_fw_type_ctl_get,
1180 .put = cs35l41_fw_type_ctl_put,
1182 struct snd_kcontrol_new fw_load_ctl = {
1183 .name = fw_load_ctl_name,
1184 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1185 .info = snd_ctl_boolean_mono_info,
1186 .get = cs35l41_fw_load_ctl_get,
1187 .put = cs35l41_fw_load_ctl_put,
1189 struct snd_kcontrol_new mute_override_ctl = {
1190 .name = mute_override_ctl_name,
1191 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1192 .info = snd_ctl_boolean_mono_info,
1193 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1194 .get = cs35l41_mute_override_ctl_get,
1198 scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type",
1200 scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load",
1202 scnprintf(mute_override_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s Forced Mute Status",
1205 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
1207 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
1211 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
1213 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
1215 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
1219 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
1221 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&mute_override_ctl, cs35l41));
1223 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", mute_override_ctl.name,
1228 dev_dbg(cs35l41->dev, "Added Control %s\n", mute_override_ctl.name);
1233 static bool cs35l41_dsm_supported(acpi_handle handle, unsigned int commands)
1237 guid_parse(CS35L41_UUID, &guid);
1239 return acpi_check_dsm(handle, &guid, 0, BIT(commands));
1242 static int cs35l41_get_acpi_mute_state(struct cs35l41_hda *cs35l41, acpi_handle handle)
1245 union acpi_object *ret;
1248 guid_parse(CS35L41_UUID, &guid);
1250 if (cs35l41_dsm_supported(handle, CS35L41_DSM_GET_MUTE)) {
1251 ret = acpi_evaluate_dsm(handle, &guid, 0, CS35L41_DSM_GET_MUTE, NULL);
1252 mute = *ret->buffer.pointer;
1253 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute);
1256 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute);
1261 static void cs35l41_acpi_device_notify(acpi_handle handle, u32 event, struct device *dev)
1263 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1266 if (event != CS35L41_NOTIFY_EVENT)
1269 mute = cs35l41_get_acpi_mute_state(cs35l41, handle);
1271 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute);
1275 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute);
1276 cs35l41->mute_override = (mute > 0);
1277 cs35l41_mute(cs35l41->dev, cs35l41->mute_override);
1280 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data)
1282 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1283 struct hda_component *comps = master_data;
1284 unsigned int sleep_flags;
1287 if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
1290 comps = &comps[cs35l41->index];
1294 pm_runtime_get_sync(dev);
1296 mutex_lock(&cs35l41->fw_mutex);
1299 if (!cs35l41->acpi_subsystem_id)
1300 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1301 comps->codec->core.subsystem_id);
1302 cs35l41->codec = comps->codec;
1303 strscpy(comps->name, dev_name(dev), sizeof(comps->name));
1305 cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT;
1307 if (firmware_autostart) {
1308 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1309 cs35l41->request_fw_load = true;
1310 if (cs35l41_smart_amp(cs35l41) < 0)
1311 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1313 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1316 ret = cs35l41_create_controls(cs35l41);
1318 comps->playback_hook = cs35l41_hda_playback_hook;
1319 comps->pre_playback_hook = cs35l41_hda_pre_playback_hook;
1320 comps->post_playback_hook = cs35l41_hda_post_playback_hook;
1321 comps->acpi_notify = cs35l41_acpi_device_notify;
1322 comps->adev = cs35l41->dacpi;
1324 comps->acpi_notifications_supported = cs35l41_dsm_supported(acpi_device_handle(comps->adev),
1325 CS35L41_DSM_GET_MUTE);
1327 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41,
1328 acpi_device_handle(cs35l41->dacpi)) > 0;
1330 mutex_unlock(&cs35l41->fw_mutex);
1332 sleep_flags = lock_system_sleep();
1333 if (!device_link_add(&comps->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
1334 dev_warn(dev, "Unable to create device link\n");
1335 unlock_system_sleep(sleep_flags);
1337 pm_runtime_mark_last_busy(dev);
1338 pm_runtime_put_autosuspend(dev);
1340 dev_info(cs35l41->dev,
1341 "CS35L41 Bound - SSID: %s, BST: %d, VSPK: %d, CH: %c, FW EN: %d, SPKID: %d\n",
1342 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type,
1343 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH,
1344 cs35l41->hw_cfg.spk_pos ? 'R' : 'L',
1345 cs35l41->cs_dsp.running, cs35l41->speaker_id);
1350 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data)
1352 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1353 struct hda_component *comps = master_data;
1354 unsigned int sleep_flags;
1356 if (comps[cs35l41->index].dev == dev) {
1357 memset(&comps[cs35l41->index], 0, sizeof(*comps));
1358 sleep_flags = lock_system_sleep();
1359 device_link_remove(&comps->codec->core.dev, cs35l41->dev);
1360 unlock_system_sleep(sleep_flags);
1364 static const struct component_ops cs35l41_hda_comp_ops = {
1365 .bind = cs35l41_hda_bind,
1366 .unbind = cs35l41_hda_unbind,
1369 static irqreturn_t cs35l41_bst_short_err(int irq, void *data)
1371 struct cs35l41_hda *cs35l41 = data;
1373 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1374 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1379 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data)
1381 struct cs35l41_hda *cs35l41 = data;
1383 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1384 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1389 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data)
1391 struct cs35l41_hda *cs35l41 = data;
1393 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1394 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1399 static irqreturn_t cs35l41_temp_err(int irq, void *data)
1401 struct cs35l41_hda *cs35l41 = data;
1403 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1404 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1409 static irqreturn_t cs35l41_temp_warn(int irq, void *data)
1411 struct cs35l41_hda *cs35l41 = data;
1413 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1414 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1419 static irqreturn_t cs35l41_amp_short(int irq, void *data)
1421 struct cs35l41_hda *cs35l41 = data;
1423 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1424 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1429 static const struct cs35l41_irq cs35l41_irqs[] = {
1430 CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err),
1431 CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err),
1432 CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err),
1433 CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn),
1434 CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err),
1435 CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short),
1438 static const struct regmap_irq cs35l41_reg_irqs[] = {
1439 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR),
1440 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR),
1441 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR),
1442 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN),
1443 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR),
1444 CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR),
1447 static struct regmap_irq_chip cs35l41_regmap_irq_chip = {
1448 .name = "cs35l41 IRQ1 Controller",
1449 .status_base = CS35L41_IRQ1_STATUS1,
1450 .mask_base = CS35L41_IRQ1_MASK1,
1451 .ack_base = CS35L41_IRQ1_STATUS1,
1453 .irqs = cs35l41_reg_irqs,
1454 .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs),
1458 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1460 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1461 bool using_irq = false;
1466 if (!cs35l41->hw_cfg.valid)
1469 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1473 if (hw_cfg->gpio1.valid) {
1474 switch (hw_cfg->gpio1.func) {
1475 case CS35L41_NOT_USED:
1477 case CS35l41_VSPK_SWITCH:
1478 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO;
1479 hw_cfg->gpio1.out_en = true;
1482 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC;
1485 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1486 hw_cfg->gpio1.func);
1491 if (hw_cfg->gpio2.valid) {
1492 switch (hw_cfg->gpio2.func) {
1493 case CS35L41_NOT_USED:
1495 case CS35L41_INTERRUPT:
1497 hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN;
1500 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1505 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1507 if (cs35l41->irq && using_irq) {
1508 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1509 IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1510 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1514 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) {
1515 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1519 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1520 cs35l41_irqs[i].handler,
1521 IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1522 cs35l41_irqs[i].name, cs35l41);
1528 return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos);
1531 int cs35l41_get_speaker_id(struct device *dev, int amp_index, int num_amps, int fixed_gpio_id)
1533 struct gpio_desc *speaker_id_desc;
1534 int speaker_id = -ENODEV;
1536 if (fixed_gpio_id >= 0) {
1537 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id);
1538 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN);
1539 if (IS_ERR(speaker_id_desc)) {
1540 speaker_id = PTR_ERR(speaker_id_desc);
1543 speaker_id = gpiod_get_value_cansleep(speaker_id_desc);
1544 gpiod_put(speaker_id_desc);
1545 dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1553 count = gpiod_count(dev, "spk-id");
1556 gpios_per_amp = count / num_amps;
1557 base_index = gpios_per_amp * amp_index;
1559 if (count % num_amps)
1562 dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp);
1564 for (i = 0; i < gpios_per_amp; i++) {
1565 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index,
1567 if (IS_ERR(speaker_id_desc)) {
1568 speaker_id = PTR_ERR(speaker_id_desc);
1571 tmp = gpiod_get_value_cansleep(speaker_id_desc);
1572 gpiod_put(speaker_id_desc);
1577 speaker_id |= tmp << i;
1579 dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1585 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1587 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1588 u32 values[HDA_MAX_COMPONENTS];
1589 struct acpi_device *adev;
1590 struct device *physdev;
1596 adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1598 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1602 cs35l41->dacpi = adev;
1603 physdev = get_device(acpi_get_first_physical_node(adev));
1605 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev));
1608 cs35l41->acpi_subsystem_id = sub;
1610 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid);
1612 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n");
1616 property = "cirrus,dev-index";
1617 ret = device_property_count_u32(physdev, property);
1621 if (ret > ARRAY_SIZE(values)) {
1627 ret = device_property_read_u32_array(physdev, property, values, nval);
1631 cs35l41->index = -1;
1632 for (i = 0; i < nval; i++) {
1633 if (values[i] == id) {
1638 if (cs35l41->index == -1) {
1639 dev_err(cs35l41->dev, "No index found in %s\n", property);
1644 /* To use the same release code for all laptop variants we can't use devm_ version of
1645 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node
1647 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index,
1648 GPIOD_OUT_LOW, "cs35l41-reset");
1650 property = "cirrus,speaker-position";
1651 ret = device_property_read_u32_array(physdev, property, values, nval);
1654 hw_cfg->spk_pos = values[cs35l41->index];
1656 cs35l41->channel_index = 0;
1657 for (i = 0; i < cs35l41->index; i++)
1658 if (values[i] == hw_cfg->spk_pos)
1659 cs35l41->channel_index++;
1661 property = "cirrus,gpio1-func";
1662 ret = device_property_read_u32_array(physdev, property, values, nval);
1665 hw_cfg->gpio1.func = values[cs35l41->index];
1666 hw_cfg->gpio1.valid = true;
1668 property = "cirrus,gpio2-func";
1669 ret = device_property_read_u32_array(physdev, property, values, nval);
1672 hw_cfg->gpio2.func = values[cs35l41->index];
1673 hw_cfg->gpio2.valid = true;
1675 property = "cirrus,boost-peak-milliamp";
1676 ret = device_property_read_u32_array(physdev, property, values, nval);
1678 hw_cfg->bst_ipk = values[cs35l41->index];
1680 hw_cfg->bst_ipk = -1;
1682 property = "cirrus,boost-ind-nanohenry";
1683 ret = device_property_read_u32_array(physdev, property, values, nval);
1685 hw_cfg->bst_ind = values[cs35l41->index];
1687 hw_cfg->bst_ind = -1;
1689 property = "cirrus,boost-cap-microfarad";
1690 ret = device_property_read_u32_array(physdev, property, values, nval);
1692 hw_cfg->bst_cap = values[cs35l41->index];
1694 hw_cfg->bst_cap = -1;
1696 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1698 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0)
1699 hw_cfg->bst_type = CS35L41_INT_BOOST;
1701 hw_cfg->bst_type = CS35L41_EXT_BOOST;
1703 hw_cfg->valid = true;
1704 put_device(physdev);
1709 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1710 hw_cfg->valid = false;
1711 hw_cfg->gpio1.valid = false;
1712 hw_cfg->gpio2.valid = false;
1713 acpi_dev_put(cs35l41->dacpi);
1715 put_device(physdev);
1720 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq,
1721 struct regmap *regmap)
1723 unsigned int regid, reg_revid;
1724 struct cs35l41_hda *cs35l41;
1727 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs));
1728 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ);
1731 return PTR_ERR(regmap);
1733 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1739 cs35l41->regmap = regmap;
1740 dev_set_drvdata(dev, cs35l41);
1742 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1744 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1746 if (IS_ERR(cs35l41->reset_gpio)) {
1747 ret = PTR_ERR(cs35l41->reset_gpio);
1748 cs35l41->reset_gpio = NULL;
1749 if (ret == -EBUSY) {
1750 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1752 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1756 if (cs35l41->reset_gpio) {
1757 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1758 usleep_range(2000, 2100);
1759 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1762 usleep_range(2000, 2100);
1763 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1764 usleep_range(2000, 2100);
1766 ret = cs35l41_wait_boot_done(cs35l41);
1770 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
1774 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1778 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1782 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1784 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
1788 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1792 cs35l41_mute(cs35l41->dev, true);
1794 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
1795 mutex_init(&cs35l41->fw_mutex);
1797 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1798 pm_runtime_use_autosuspend(cs35l41->dev);
1799 pm_runtime_mark_last_busy(cs35l41->dev);
1800 pm_runtime_set_active(cs35l41->dev);
1801 pm_runtime_get_noresume(cs35l41->dev);
1802 pm_runtime_enable(cs35l41->dev);
1804 ret = cs35l41_hda_apply_properties(cs35l41);
1808 pm_runtime_put_autosuspend(cs35l41->dev);
1810 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1812 dev_err_probe(cs35l41->dev, ret, "Register component failed\n");
1816 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
1821 pm_runtime_dont_use_autosuspend(cs35l41->dev);
1822 pm_runtime_disable(cs35l41->dev);
1823 pm_runtime_put_noidle(cs35l41->dev);
1826 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1827 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1828 gpiod_put(cs35l41->reset_gpio);
1829 gpiod_put(cs35l41->cs_gpio);
1830 acpi_dev_put(cs35l41->dacpi);
1831 kfree(cs35l41->acpi_subsystem_id);
1835 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, SND_HDA_SCODEC_CS35L41);
1837 void cs35l41_hda_remove(struct device *dev)
1839 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1841 pm_runtime_get_sync(cs35l41->dev);
1842 pm_runtime_dont_use_autosuspend(cs35l41->dev);
1843 pm_runtime_disable(cs35l41->dev);
1845 if (cs35l41->halo_initialized)
1846 cs35l41_remove_dsp(cs35l41);
1848 component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
1850 acpi_dev_put(cs35l41->dacpi);
1852 pm_runtime_put_noidle(cs35l41->dev);
1854 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1855 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1856 gpiod_put(cs35l41->reset_gpio);
1857 gpiod_put(cs35l41->cs_gpio);
1858 kfree(cs35l41->acpi_subsystem_id);
1860 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41);
1862 const struct dev_pm_ops cs35l41_hda_pm_ops = {
1863 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume,
1864 cs35l41_runtime_idle)
1865 .prepare = cs35l41_system_suspend_prep,
1866 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume)
1868 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41);
1870 MODULE_DESCRIPTION("CS35L41 HDA Driver");
1871 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
1872 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
1873 MODULE_LICENSE("GPL");
1874 MODULE_IMPORT_NS(FW_CS_DSP);