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