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