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