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 mutex_lock(&cs35l41->fw_mutex);
628 cs35l41_shutdown_dsp(cs35l41);
629 cs_dsp_remove(dsp);
630 cs35l41->halo_initialized = false;
631 mutex_unlock(&cs35l41->fw_mutex);
632 }
633
634 /* Protection release cycle to get the speaker out of Safe-Mode */
cs35l41_error_release(struct device * dev,struct regmap * regmap,unsigned int mask)635 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask)
636 {
637 regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0);
638 regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
639 regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
640 }
641
642 /* Clear all errors to release safe mode. Global Enable must be cleared first. */
cs35l41_irq_release(struct cs35l41_hda * cs35l41)643 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
644 {
645 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
646 cs35l41->irq_errors = 0;
647 }
648
cs35l41_update_mixer(struct cs35l41_hda * cs35l41)649 static void cs35l41_update_mixer(struct cs35l41_hda *cs35l41)
650 {
651 struct regmap *reg = cs35l41->regmap;
652 unsigned int asp_en = 0;
653 unsigned int dsp1rx2_src = 0;
654
655 regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config));
656
657 if (cs35l41->cs_dsp.running) {
658 asp_en |= CS35L41_ASP_TX1_EN_MASK; // ASP_TX1_EN = 1
659 regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
660 ARRAY_SIZE(cs35l41_hda_config_dsp));
661 if (cs35l41->hw_cfg.bst_type == CS35L41_INT_BOOST)
662 regmap_write(reg, CS35L41_DSP1_RX5_SRC, CS35L41_INPUT_SRC_VPMON);
663 else
664 regmap_write(reg, CS35L41_DSP1_RX5_SRC, CS35L41_INPUT_SRC_VBSTMON);
665 } else {
666 regmap_multi_reg_write(reg, cs35l41_hda_config_no_dsp,
667 ARRAY_SIZE(cs35l41_hda_config_no_dsp));
668 }
669
670 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER) {
671 asp_en |= CS35L41_ASP_RX2_EN_MASK; // ASP_RX2_EN = 1
672 dsp1rx2_src = 0x00000009; // DSP1RX2 SRC = ASPRX2
673 } else {
674 dsp1rx2_src = 0x00000008; // DSP1RX2 SRC = ASPRX1
675 }
676
677 asp_en |= CS35L41_ASP_RX1_EN_MASK; // ASP_RX1_EN = 1
678
679 regmap_write(reg, CS35L41_SP_ENABLES, asp_en);
680 regmap_write(reg, CS35L41_DSP1_RX1_SRC, 0x00000008); // DSP1RX1 SRC = ASPRX1
681 regmap_write(reg, CS35L41_DSP1_RX2_SRC, dsp1rx2_src);
682 }
683
cs35l41_hda_play_start(struct device * dev)684 static void cs35l41_hda_play_start(struct device *dev)
685 {
686 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
687 struct regmap *reg = cs35l41->regmap;
688
689 dev_dbg(dev, "Play (Start)\n");
690
691 if (cs35l41->playback_started) {
692 dev_dbg(dev, "Playback already started.");
693 return;
694 }
695
696 cs35l41->playback_started = true;
697
698 cs35l41_update_mixer(cs35l41);
699
700 if (cs35l41->cs_dsp.running) {
701 regmap_update_bits(reg, CS35L41_PWR_CTRL2,
702 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
703 1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
704 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
705 }
706 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
707 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
708 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
709
710 }
711
cs35l41_mute(struct device * dev,bool mute)712 static void cs35l41_mute(struct device *dev, bool mute)
713 {
714 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
715 struct regmap *reg = cs35l41->regmap;
716 unsigned int amp_gain;
717
718 dev_dbg(dev, "Mute(%d:%d) Playback Started: %d\n", mute, cs35l41->mute_override,
719 cs35l41->playback_started);
720
721 if (cs35l41->playback_started) {
722 if (mute || cs35l41->mute_override) {
723 dev_dbg(dev, "Muting\n");
724 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
725 } else {
726 dev_dbg(dev, "Unmuting\n");
727 if (cs35l41->cs_dsp.running) {
728 dev_dbg(dev, "Using Tuned Gain: %d\n", cs35l41->tuning_gain);
729 amp_gain = (cs35l41->tuning_gain << CS35L41_AMP_GAIN_PCM_SHIFT) |
730 (DEFAULT_AMP_GAIN_PDM << CS35L41_AMP_GAIN_PDM_SHIFT);
731
732 /* AMP_HPF_PCM_EN = 1, AMP_VOL_PCM 0.0 dB */
733 regmap_write(reg, CS35L41_AMP_DIG_VOL_CTRL, 0x00008000);
734 regmap_write(reg, CS35L41_AMP_GAIN_CTRL, amp_gain);
735 } else {
736 regmap_multi_reg_write(reg, cs35l41_hda_unmute,
737 ARRAY_SIZE(cs35l41_hda_unmute));
738 }
739 }
740 }
741 }
742
cs35l41_hda_play_done(struct device * dev)743 static void cs35l41_hda_play_done(struct device *dev)
744 {
745 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
746 struct regmap *reg = cs35l41->regmap;
747
748 dev_dbg(dev, "Play (Complete)\n");
749
750 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1,
751 &cs35l41->cs_dsp);
752 cs35l41_mute(dev, false);
753 }
754
cs35l41_hda_pause_start(struct device * dev)755 static void cs35l41_hda_pause_start(struct device *dev)
756 {
757 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
758 struct regmap *reg = cs35l41->regmap;
759
760 dev_dbg(dev, "Pause (Start)\n");
761
762 cs35l41_mute(dev, true);
763 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0,
764 &cs35l41->cs_dsp);
765 }
766
cs35l41_hda_pause_done(struct device * dev)767 static void cs35l41_hda_pause_done(struct device *dev)
768 {
769 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
770 struct regmap *reg = cs35l41->regmap;
771
772 dev_dbg(dev, "Pause (Complete)\n");
773
774 regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
775 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
776 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
777 if (cs35l41->cs_dsp.running) {
778 cs35l41_set_cspl_mbox_cmd(dev, reg, CSPL_MBOX_CMD_PAUSE);
779 regmap_update_bits(reg, CS35L41_PWR_CTRL2,
780 CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
781 0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
782 }
783 cs35l41_irq_release(cs35l41);
784 cs35l41->playback_started = false;
785 }
786
cs35l41_hda_pre_playback_hook(struct device * dev,int action)787 static void cs35l41_hda_pre_playback_hook(struct device *dev, int action)
788 {
789 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
790
791 switch (action) {
792 case HDA_GEN_PCM_ACT_CLEANUP:
793 mutex_lock(&cs35l41->fw_mutex);
794 cs35l41_hda_pause_start(dev);
795 mutex_unlock(&cs35l41->fw_mutex);
796 break;
797 default:
798 break;
799 }
800 }
cs35l41_hda_playback_hook(struct device * dev,int action)801 static void cs35l41_hda_playback_hook(struct device *dev, int action)
802 {
803 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
804
805 switch (action) {
806 case HDA_GEN_PCM_ACT_OPEN:
807 /*
808 * All amps must be resumed before we can start playing back.
809 * This ensures, for external boost, that all amps are in AMP_SAFE mode.
810 * Do this in HDA_GEN_PCM_ACT_OPEN, since this is run prior to any of the
811 * other actions.
812 */
813 pm_runtime_get_sync(dev);
814 break;
815 case HDA_GEN_PCM_ACT_PREPARE:
816 mutex_lock(&cs35l41->fw_mutex);
817 cs35l41_hda_play_start(dev);
818 mutex_unlock(&cs35l41->fw_mutex);
819 break;
820 case HDA_GEN_PCM_ACT_CLEANUP:
821 mutex_lock(&cs35l41->fw_mutex);
822 cs35l41_hda_pause_done(dev);
823 mutex_unlock(&cs35l41->fw_mutex);
824 break;
825 case HDA_GEN_PCM_ACT_CLOSE:
826 mutex_lock(&cs35l41->fw_mutex);
827 if (!cs35l41->cs_dsp.running && cs35l41->request_fw_load &&
828 !cs35l41->fw_request_ongoing) {
829 dev_info(dev, "Requesting Firmware Load after HDA_GEN_PCM_ACT_CLOSE\n");
830 cs35l41->fw_request_ongoing = true;
831 schedule_work(&cs35l41->fw_load_work);
832 }
833 mutex_unlock(&cs35l41->fw_mutex);
834
835 /*
836 * Playback must be finished for all amps before we start runtime suspend.
837 * This ensures no amps are playing back when we start putting them to sleep.
838 */
839 pm_runtime_put_autosuspend(dev);
840 break;
841 default:
842 break;
843 }
844 }
845
cs35l41_hda_post_playback_hook(struct device * dev,int action)846 static void cs35l41_hda_post_playback_hook(struct device *dev, int action)
847 {
848 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
849
850 switch (action) {
851 case HDA_GEN_PCM_ACT_PREPARE:
852 mutex_lock(&cs35l41->fw_mutex);
853 cs35l41_hda_play_done(dev);
854 mutex_unlock(&cs35l41->fw_mutex);
855 break;
856 default:
857 break;
858 }
859 }
860
cs35l41_hda_channel_map(struct cs35l41_hda * cs35l41)861 static int cs35l41_hda_channel_map(struct cs35l41_hda *cs35l41)
862 {
863 unsigned int tx_num = 0;
864 unsigned int *tx_slot = NULL;
865 unsigned int rx_num;
866 unsigned int *rx_slot;
867 unsigned int mono = 0;
868
869 if (!cs35l41->amp_name) {
870 if (cs35l41->hw_cfg.spk_pos >= ARRAY_SIZE(channel_name))
871 return -EINVAL;
872
873 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%c%d",
874 channel_name[cs35l41->hw_cfg.spk_pos],
875 cs35l41->channel_index);
876 if (!cs35l41->amp_name)
877 return -ENOMEM;
878 }
879
880 rx_num = 1;
881 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER)
882 rx_slot = &mono;
883 else
884 rx_slot = &cs35l41->hw_cfg.spk_pos;
885
886 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
887 rx_slot);
888 }
889
cs35l41_verify_id(struct cs35l41_hda * cs35l41,unsigned int * regid,unsigned int * reg_revid)890 static int cs35l41_verify_id(struct cs35l41_hda *cs35l41, unsigned int *regid, unsigned int *reg_revid)
891 {
892 unsigned int mtl_revid, chipid;
893 int ret;
894
895 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, regid);
896 if (ret) {
897 dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n");
898 return ret;
899 }
900
901 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, reg_revid);
902 if (ret) {
903 dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n");
904 return ret;
905 }
906
907 mtl_revid = *reg_revid & CS35L41_MTLREVID_MASK;
908
909 chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID;
910 if (*regid != chipid) {
911 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", *regid, chipid);
912 return -ENODEV;
913 }
914
915 return 0;
916 }
917
cs35l41_ready_for_reset(struct cs35l41_hda * cs35l41)918 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
919 {
920 mutex_lock(&cs35l41->fw_mutex);
921 if (cs35l41->cs_dsp.running) {
922 cs35l41->cs_dsp.running = false;
923 cs35l41->cs_dsp.booted = false;
924 }
925 regcache_mark_dirty(cs35l41->regmap);
926 mutex_unlock(&cs35l41->fw_mutex);
927
928 return 0;
929 }
930
cs35l41_system_suspend_prep(struct device * dev)931 static int cs35l41_system_suspend_prep(struct device *dev)
932 {
933 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
934
935 dev_dbg(cs35l41->dev, "System Suspend Prepare\n");
936
937 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
938 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
939 return 0; /* don't block the whole system suspend */
940 }
941
942 mutex_lock(&cs35l41->fw_mutex);
943 if (cs35l41->playback_started)
944 cs35l41_hda_pause_start(dev);
945 mutex_unlock(&cs35l41->fw_mutex);
946
947 return 0;
948 }
949
cs35l41_system_suspend(struct device * dev)950 static int cs35l41_system_suspend(struct device *dev)
951 {
952 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
953 int ret;
954
955 dev_dbg(cs35l41->dev, "System Suspend\n");
956
957 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
958 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
959 return 0; /* don't block the whole system suspend */
960 }
961
962 mutex_lock(&cs35l41->fw_mutex);
963 if (cs35l41->playback_started)
964 cs35l41_hda_pause_done(dev);
965 mutex_unlock(&cs35l41->fw_mutex);
966
967 ret = pm_runtime_force_suspend(dev);
968 if (ret) {
969 dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret);
970 return ret;
971 }
972
973 /* Shutdown DSP before system suspend */
974 ret = cs35l41_ready_for_reset(cs35l41);
975 if (ret)
976 dev_err(dev, "System Suspend Failed, not ready for Reset: %d\n", ret);
977
978 if (cs35l41->reset_gpio) {
979 dev_info(cs35l41->dev, "Asserting Reset\n");
980 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
981 usleep_range(2000, 2100);
982 }
983
984 dev_dbg(cs35l41->dev, "System Suspended\n");
985
986 return ret;
987 }
988
cs35l41_wait_boot_done(struct cs35l41_hda * cs35l41)989 static int cs35l41_wait_boot_done(struct cs35l41_hda *cs35l41)
990 {
991 unsigned int int_status;
992 int ret;
993
994 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
995 int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000);
996 if (ret) {
997 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE\n");
998 return ret;
999 }
1000
1001 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_status);
1002 if (ret || (int_status & CS35L41_OTP_BOOT_ERR)) {
1003 dev_err(cs35l41->dev, "OTP Boot status %x error\n",
1004 int_status & CS35L41_OTP_BOOT_ERR);
1005 if (!ret)
1006 ret = -EIO;
1007 return ret;
1008 }
1009
1010 return 0;
1011 }
1012
cs35l41_system_resume(struct device * dev)1013 static int cs35l41_system_resume(struct device *dev)
1014 {
1015 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1016 int ret;
1017
1018 dev_dbg(cs35l41->dev, "System Resume\n");
1019
1020 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1021 dev_err_once(cs35l41->dev, "System Resume not supported\n");
1022 return 0; /* don't block the whole system resume */
1023 }
1024
1025 if (cs35l41->reset_gpio) {
1026 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1027 usleep_range(2000, 2100);
1028 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1029 }
1030
1031 usleep_range(2000, 2100);
1032
1033 regcache_cache_only(cs35l41->regmap, false);
1034
1035 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1036 usleep_range(2000, 2100);
1037
1038 ret = cs35l41_wait_boot_done(cs35l41);
1039 if (ret)
1040 return ret;
1041
1042 regcache_cache_only(cs35l41->regmap, true);
1043
1044 ret = pm_runtime_force_resume(dev);
1045 if (ret) {
1046 dev_err(dev, "System Resume Failed: Unable to runtime resume: %d\n", ret);
1047 return ret;
1048 }
1049
1050 mutex_lock(&cs35l41->fw_mutex);
1051
1052 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
1053 cs35l41->fw_request_ongoing = true;
1054 schedule_work(&cs35l41->fw_load_work);
1055 }
1056 mutex_unlock(&cs35l41->fw_mutex);
1057
1058 return ret;
1059 }
1060
cs35l41_runtime_idle(struct device * dev)1061 static int cs35l41_runtime_idle(struct device *dev)
1062 {
1063 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1064
1065 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH)
1066 return -EBUSY; /* suspend not supported yet on this model */
1067 return 0;
1068 }
1069
cs35l41_runtime_suspend(struct device * dev)1070 static int cs35l41_runtime_suspend(struct device *dev)
1071 {
1072 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1073 int ret = 0;
1074
1075 dev_dbg(cs35l41->dev, "Runtime Suspend\n");
1076
1077 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1078 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n");
1079 return 0;
1080 }
1081
1082 mutex_lock(&cs35l41->fw_mutex);
1083
1084 if (cs35l41->cs_dsp.running) {
1085 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
1086 cs35l41->hw_cfg.bst_type);
1087 if (ret)
1088 goto err;
1089 } else {
1090 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
1091 }
1092
1093 regcache_cache_only(cs35l41->regmap, true);
1094 regcache_mark_dirty(cs35l41->regmap);
1095
1096 err:
1097 mutex_unlock(&cs35l41->fw_mutex);
1098
1099 return ret;
1100 }
1101
cs35l41_runtime_resume(struct device * dev)1102 static int cs35l41_runtime_resume(struct device *dev)
1103 {
1104 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1105 unsigned int regid, reg_revid;
1106 int ret = 0;
1107
1108 dev_dbg(cs35l41->dev, "Runtime Resume\n");
1109
1110 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1111 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n");
1112 return 0;
1113 }
1114
1115 mutex_lock(&cs35l41->fw_mutex);
1116
1117 regcache_cache_only(cs35l41->regmap, false);
1118
1119 if (cs35l41->cs_dsp.running) {
1120 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
1121 if (ret) {
1122 dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
1123 goto err;
1124 }
1125 }
1126
1127 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
1128 if (ret)
1129 goto err;
1130
1131 /* Test key needs to be unlocked to allow the OTP settings to re-apply */
1132 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1133 ret = regcache_sync(cs35l41->regmap);
1134 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1135 if (ret) {
1136 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
1137 goto err;
1138 }
1139
1140 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
1141 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
1142
1143 dev_dbg(cs35l41->dev, "CS35L41 Resumed (%x), Revision: %02X\n", regid, reg_revid);
1144
1145 err:
1146 mutex_unlock(&cs35l41->fw_mutex);
1147
1148 return ret;
1149 }
1150
cs35l41_hda_read_ctl(struct cs_dsp * dsp,const char * name,int type,unsigned int alg,void * buf,size_t len)1151 static int cs35l41_hda_read_ctl(struct cs_dsp *dsp, const char *name, int type,
1152 unsigned int alg, void *buf, size_t len)
1153 {
1154 int ret;
1155
1156 mutex_lock(&dsp->pwr_lock);
1157 ret = cs_dsp_coeff_read_ctrl(cs_dsp_get_ctl(dsp, name, type, alg), 0, buf, len);
1158 mutex_unlock(&dsp->pwr_lock);
1159
1160 return ret;
1161 }
1162
cs35l41_smart_amp(struct cs35l41_hda * cs35l41)1163 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
1164 {
1165 unsigned int fw_status;
1166 __be32 halo_sts;
1167 int ret;
1168
1169 if (cs35l41->bypass_fw) {
1170 dev_warn(cs35l41->dev, "Bypassing Firmware.\n");
1171 return 0;
1172 }
1173
1174 ret = cs35l41_init_dsp(cs35l41);
1175 if (ret) {
1176 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
1177 goto clean_dsp;
1178 }
1179
1180 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
1181 if (ret) {
1182 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
1183 goto clean_dsp;
1184 }
1185
1186 ret = cs_dsp_run(&cs35l41->cs_dsp);
1187 if (ret) {
1188 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
1189 goto clean_dsp;
1190 }
1191
1192 ret = read_poll_timeout(cs35l41_hda_read_ctl, ret,
1193 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN,
1194 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
1195 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG,
1196 &halo_sts, sizeof(halo_sts));
1197
1198 if (ret) {
1199 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n",
1200 halo_sts);
1201 goto clean_dsp;
1202 }
1203
1204 ret = regmap_read(cs35l41->regmap, CS35L41_DSP_MBOX_2, &fw_status);
1205 if (ret < 0) {
1206 dev_err(cs35l41->dev,
1207 "Failed to read firmware status: %d\n", ret);
1208 goto clean_dsp;
1209 }
1210
1211 switch (fw_status) {
1212 case CSPL_MBOX_STS_RUNNING:
1213 case CSPL_MBOX_STS_PAUSED:
1214 break;
1215 default:
1216 dev_err(cs35l41->dev, "Firmware status is invalid: %u\n",
1217 fw_status);
1218 ret = -EINVAL;
1219 goto clean_dsp;
1220 }
1221
1222 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
1223 if (ret) {
1224 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
1225 goto clean_dsp;
1226 }
1227
1228 dev_info(cs35l41->dev, "Firmware Loaded - Type: %s, Gain: %d\n",
1229 cs35l41_hda_fw_ids[cs35l41->firmware_type], cs35l41->tuning_gain);
1230
1231 return 0;
1232
1233 clean_dsp:
1234 cs35l41_shutdown_dsp(cs35l41);
1235 return ret;
1236 }
1237
cs35l41_load_firmware(struct cs35l41_hda * cs35l41,bool load)1238 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
1239 {
1240 if (cs35l41->cs_dsp.running && !load) {
1241 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
1242 cs35l41_shutdown_dsp(cs35l41);
1243 } else if (!cs35l41->cs_dsp.running && load) {
1244 dev_dbg(cs35l41->dev, "Loading Firmware\n");
1245 cs35l41_smart_amp(cs35l41);
1246 } else {
1247 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
1248 }
1249 }
1250
cs35l41_fw_load_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1251 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol,
1252 struct snd_ctl_elem_value *ucontrol)
1253 {
1254 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1255
1256 ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
1257 return 0;
1258 }
1259
cs35l41_mute_override_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1260 static int cs35l41_mute_override_ctl_get(struct snd_kcontrol *kcontrol,
1261 struct snd_ctl_elem_value *ucontrol)
1262 {
1263 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1264
1265 ucontrol->value.integer.value[0] = cs35l41->mute_override;
1266 return 0;
1267 }
1268
cs35l41_fw_load_work(struct work_struct * work)1269 static void cs35l41_fw_load_work(struct work_struct *work)
1270 {
1271 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
1272
1273 pm_runtime_get_sync(cs35l41->dev);
1274
1275 mutex_lock(&cs35l41->fw_mutex);
1276
1277 /* Recheck if playback is ongoing, mutex will block playback during firmware loading */
1278 if (cs35l41->playback_started)
1279 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n");
1280 else
1281 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
1282
1283 cs35l41->fw_request_ongoing = false;
1284 mutex_unlock(&cs35l41->fw_mutex);
1285
1286 pm_runtime_put_autosuspend(cs35l41->dev);
1287 }
1288
cs35l41_fw_load_ctl_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1289 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol,
1290 struct snd_ctl_elem_value *ucontrol)
1291 {
1292 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1293
1294 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
1295 return 0;
1296
1297 if (cs35l41->fw_request_ongoing) {
1298 dev_dbg(cs35l41->dev, "Existing request not complete\n");
1299 return -EBUSY;
1300 }
1301
1302 /* Check if playback is ongoing when initial request is made */
1303 if (cs35l41->playback_started) {
1304 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
1305 return -EBUSY;
1306 }
1307
1308 cs35l41->fw_request_ongoing = true;
1309 cs35l41->request_fw_load = ucontrol->value.integer.value[0];
1310 schedule_work(&cs35l41->fw_load_work);
1311
1312 return 1;
1313 }
1314
cs35l41_fw_type_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1315 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol,
1316 struct snd_ctl_elem_value *ucontrol)
1317 {
1318 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1319
1320 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
1321
1322 return 0;
1323 }
1324
cs35l41_fw_type_ctl_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1325 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol,
1326 struct snd_ctl_elem_value *ucontrol)
1327 {
1328 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1329
1330 if (ucontrol->value.enumerated.item[0] < CS35L41_HDA_NUM_FW) {
1331 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) {
1332 cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
1333 return 1;
1334 } else {
1335 return 0;
1336 }
1337 }
1338
1339 return -EINVAL;
1340 }
1341
cs35l41_fw_type_ctl_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1342 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1343 {
1344 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(cs35l41_hda_fw_ids), cs35l41_hda_fw_ids);
1345 }
1346
cs35l41_create_controls(struct cs35l41_hda * cs35l41)1347 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
1348 {
1349 char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1350 char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1351 char mute_override_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1352 struct snd_kcontrol_new fw_type_ctl = {
1353 .name = fw_type_ctl_name,
1354 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1355 .info = cs35l41_fw_type_ctl_info,
1356 .get = cs35l41_fw_type_ctl_get,
1357 .put = cs35l41_fw_type_ctl_put,
1358 };
1359 struct snd_kcontrol_new fw_load_ctl = {
1360 .name = fw_load_ctl_name,
1361 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1362 .info = snd_ctl_boolean_mono_info,
1363 .get = cs35l41_fw_load_ctl_get,
1364 .put = cs35l41_fw_load_ctl_put,
1365 };
1366 struct snd_kcontrol_new mute_override_ctl = {
1367 .name = mute_override_ctl_name,
1368 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1369 .info = snd_ctl_boolean_mono_info,
1370 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1371 .get = cs35l41_mute_override_ctl_get,
1372 };
1373 int ret;
1374
1375 scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type",
1376 cs35l41->amp_name);
1377 scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load",
1378 cs35l41->amp_name);
1379 scnprintf(mute_override_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s Forced Mute Status",
1380 cs35l41->amp_name);
1381
1382 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
1383 if (ret) {
1384 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
1385 return ret;
1386 }
1387
1388 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
1389
1390 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
1391 if (ret) {
1392 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
1393 return ret;
1394 }
1395
1396 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
1397
1398 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&mute_override_ctl, cs35l41));
1399 if (ret) {
1400 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", mute_override_ctl.name,
1401 ret);
1402 return ret;
1403 }
1404
1405 dev_dbg(cs35l41->dev, "Added Control %s\n", mute_override_ctl.name);
1406
1407 return 0;
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(handle, &guid, 0, CS35L41_DSM_GET_MUTE, NULL);
1429 mute = *ret->buffer.pointer;
1430 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute);
1431 }
1432
1433 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute);
1434
1435 return mute;
1436 }
1437
cs35l41_acpi_device_notify(acpi_handle handle,u32 event,struct device * dev)1438 static void cs35l41_acpi_device_notify(acpi_handle handle, u32 event, struct device *dev)
1439 {
1440 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1441 int mute;
1442
1443 if (event != CS35L41_NOTIFY_EVENT)
1444 return;
1445
1446 mute = cs35l41_get_acpi_mute_state(cs35l41, handle);
1447 if (mute < 0) {
1448 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute);
1449 return;
1450 }
1451
1452 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute);
1453 cs35l41->mute_override = (mute > 0);
1454 cs35l41_mute(cs35l41->dev, cs35l41->mute_override);
1455 }
1456
cs35l41_hda_bind(struct device * dev,struct device * master,void * master_data)1457 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data)
1458 {
1459 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1460 struct hda_component_parent *parent = master_data;
1461 struct hda_component *comp;
1462 unsigned int sleep_flags;
1463 int ret = 0;
1464
1465 comp = hda_component_from_index(parent, cs35l41->index);
1466 if (!comp)
1467 return -EINVAL;
1468
1469 if (comp->dev)
1470 return -EBUSY;
1471
1472 pm_runtime_get_sync(dev);
1473
1474 mutex_lock(&cs35l41->fw_mutex);
1475
1476 comp->dev = dev;
1477 cs35l41->codec = parent->codec;
1478 if (!cs35l41->acpi_subsystem_id)
1479 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1480 cs35l41->codec->core.subsystem_id);
1481
1482 strscpy(comp->name, dev_name(dev), sizeof(comp->name));
1483
1484 cs35l41->firmware_type = CS35L41_HDA_FW_SPK_PROT;
1485
1486 if (firmware_autostart) {
1487 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1488 cs35l41->request_fw_load = true;
1489 if (cs35l41_smart_amp(cs35l41) < 0)
1490 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1491 } else {
1492 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1493 }
1494
1495 ret = cs35l41_create_controls(cs35l41);
1496
1497 comp->playback_hook = cs35l41_hda_playback_hook;
1498 comp->pre_playback_hook = cs35l41_hda_pre_playback_hook;
1499 comp->post_playback_hook = cs35l41_hda_post_playback_hook;
1500 comp->acpi_notify = cs35l41_acpi_device_notify;
1501 comp->adev = cs35l41->dacpi;
1502
1503 comp->acpi_notifications_supported = cs35l41_dsm_supported(acpi_device_handle(comp->adev),
1504 CS35L41_DSM_GET_MUTE);
1505
1506 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41,
1507 acpi_device_handle(cs35l41->dacpi)) > 0;
1508
1509 mutex_unlock(&cs35l41->fw_mutex);
1510
1511 sleep_flags = lock_system_sleep();
1512 if (!device_link_add(&cs35l41->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
1513 dev_warn(dev, "Unable to create device link\n");
1514 unlock_system_sleep(sleep_flags);
1515
1516 pm_runtime_put_autosuspend(dev);
1517
1518 dev_info(cs35l41->dev,
1519 "CS35L41 Bound - SSID: %s, BST: %d, VSPK: %d, CH: %c, FW EN: %d, SPKID: %d\n",
1520 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type,
1521 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH,
1522 channel_name[cs35l41->hw_cfg.spk_pos],
1523 cs35l41->cs_dsp.running, cs35l41->speaker_id);
1524
1525 return ret;
1526 }
1527
cs35l41_hda_unbind(struct device * dev,struct device * master,void * master_data)1528 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data)
1529 {
1530 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1531 struct hda_component_parent *parent = master_data;
1532 struct hda_component *comp;
1533 unsigned int sleep_flags;
1534
1535 comp = hda_component_from_index(parent, cs35l41->index);
1536 if (!comp)
1537 return;
1538
1539 if (comp->dev == dev) {
1540 sleep_flags = lock_system_sleep();
1541 device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev);
1542 unlock_system_sleep(sleep_flags);
1543 memset(comp, 0, sizeof(*comp));
1544 }
1545 }
1546
1547 static const struct component_ops cs35l41_hda_comp_ops = {
1548 .bind = cs35l41_hda_bind,
1549 .unbind = cs35l41_hda_unbind,
1550 };
1551
cs35l41_bst_short_err(int irq,void * data)1552 static irqreturn_t cs35l41_bst_short_err(int irq, void *data)
1553 {
1554 struct cs35l41_hda *cs35l41 = data;
1555
1556 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1557 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1558
1559 return IRQ_HANDLED;
1560 }
1561
cs35l41_bst_dcm_uvp_err(int irq,void * data)1562 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data)
1563 {
1564 struct cs35l41_hda *cs35l41 = data;
1565
1566 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1567 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1568
1569 return IRQ_HANDLED;
1570 }
1571
cs35l41_bst_ovp_err(int irq,void * data)1572 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data)
1573 {
1574 struct cs35l41_hda *cs35l41 = data;
1575
1576 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1577 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1578
1579 return IRQ_HANDLED;
1580 }
1581
cs35l41_temp_err(int irq,void * data)1582 static irqreturn_t cs35l41_temp_err(int irq, void *data)
1583 {
1584 struct cs35l41_hda *cs35l41 = data;
1585
1586 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1587 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1588
1589 return IRQ_HANDLED;
1590 }
1591
cs35l41_temp_warn(int irq,void * data)1592 static irqreturn_t cs35l41_temp_warn(int irq, void *data)
1593 {
1594 struct cs35l41_hda *cs35l41 = data;
1595
1596 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1597 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1598
1599 return IRQ_HANDLED;
1600 }
1601
cs35l41_amp_short(int irq,void * data)1602 static irqreturn_t cs35l41_amp_short(int irq, void *data)
1603 {
1604 struct cs35l41_hda *cs35l41 = data;
1605
1606 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1607 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1608
1609 return IRQ_HANDLED;
1610 }
1611
1612 static const struct cs35l41_irq cs35l41_irqs[] = {
1613 CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err),
1614 CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err),
1615 CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err),
1616 CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn),
1617 CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err),
1618 CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short),
1619 };
1620
1621 static const struct regmap_irq cs35l41_reg_irqs[] = {
1622 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR),
1623 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR),
1624 CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR),
1625 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN),
1626 CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR),
1627 CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR),
1628 };
1629
1630 static const struct regmap_irq_chip cs35l41_regmap_irq_chip = {
1631 .name = "cs35l41 IRQ1 Controller",
1632 .status_base = CS35L41_IRQ1_STATUS1,
1633 .mask_base = CS35L41_IRQ1_MASK1,
1634 .ack_base = CS35L41_IRQ1_STATUS1,
1635 .num_regs = 4,
1636 .irqs = cs35l41_reg_irqs,
1637 .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs),
1638 .runtime_pm = true,
1639 };
1640
cs35l41_configure_interrupt(struct cs35l41_hda * cs35l41,int irq_pol)1641 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol)
1642 {
1643 int irq;
1644 int ret;
1645 int i;
1646
1647 if (!cs35l41->irq) {
1648 dev_warn(cs35l41->dev, "No Interrupt Found");
1649 goto err;
1650 }
1651
1652 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1653 IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1654 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1655 if (ret) {
1656 dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret);
1657 goto err;
1658 }
1659
1660 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) {
1661 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1662 if (irq < 0) {
1663 ret = irq;
1664 dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name,
1665 ret);
1666 goto err;
1667 }
1668
1669 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1670 cs35l41_irqs[i].handler,
1671 IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1672 cs35l41_irqs[i].name, cs35l41);
1673 if (ret) {
1674 dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.",
1675 cs35l41_irqs[i].name, ret);
1676 goto err;
1677 }
1678 }
1679 return;
1680 err:
1681 dev_warn(cs35l41->dev,
1682 "IRQ Config Failed. Amp errors may not be recoverable without reboot.");
1683 }
1684
cs35l41_hda_apply_properties(struct cs35l41_hda * cs35l41)1685 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1686 {
1687 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1688 bool using_irq = false;
1689 int irq_pol;
1690 int ret;
1691
1692 if (!cs35l41->hw_cfg.valid)
1693 return -EINVAL;
1694
1695 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1696 if (ret)
1697 return ret;
1698
1699 if (hw_cfg->gpio1.valid) {
1700 switch (hw_cfg->gpio1.func) {
1701 case CS35L41_NOT_USED:
1702 break;
1703 case CS35l41_VSPK_SWITCH:
1704 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO;
1705 hw_cfg->gpio1.out_en = true;
1706 break;
1707 case CS35l41_SYNC:
1708 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC;
1709 break;
1710 default:
1711 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1712 hw_cfg->gpio1.func);
1713 return -EINVAL;
1714 }
1715 }
1716
1717 if (hw_cfg->gpio2.valid) {
1718 switch (hw_cfg->gpio2.func) {
1719 case CS35L41_NOT_USED:
1720 break;
1721 case CS35L41_INTERRUPT:
1722 using_irq = true;
1723 hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN;
1724 break;
1725 default:
1726 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1727 return -EINVAL;
1728 }
1729 }
1730
1731 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1732
1733 if (using_irq)
1734 cs35l41_configure_interrupt(cs35l41, irq_pol);
1735
1736 return cs35l41_hda_channel_map(cs35l41);
1737 }
1738
cs35l41_get_speaker_id(struct device * dev,int amp_index,int num_amps,int fixed_gpio_id)1739 int cs35l41_get_speaker_id(struct device *dev, int amp_index, int num_amps, int fixed_gpio_id)
1740 {
1741 struct gpio_desc *speaker_id_desc;
1742 int speaker_id = -ENODEV;
1743
1744 if (fixed_gpio_id >= 0) {
1745 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id);
1746 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN);
1747 if (IS_ERR(speaker_id_desc)) {
1748 speaker_id = PTR_ERR(speaker_id_desc);
1749 return speaker_id;
1750 }
1751 speaker_id = gpiod_get_value_cansleep(speaker_id_desc);
1752 gpiod_put(speaker_id_desc);
1753 dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1754 } else {
1755 int base_index;
1756 int gpios_per_amp;
1757 int count;
1758 int tmp;
1759 int i;
1760
1761 count = gpiod_count(dev, "spk-id");
1762 if (count > 0) {
1763 speaker_id = 0;
1764 gpios_per_amp = count / num_amps;
1765 base_index = gpios_per_amp * amp_index;
1766
1767 if (count % num_amps)
1768 return -EINVAL;
1769
1770 dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp);
1771
1772 for (i = 0; i < gpios_per_amp; i++) {
1773 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index,
1774 GPIOD_IN);
1775 if (IS_ERR(speaker_id_desc)) {
1776 speaker_id = PTR_ERR(speaker_id_desc);
1777 break;
1778 }
1779 tmp = gpiod_get_value_cansleep(speaker_id_desc);
1780 gpiod_put(speaker_id_desc);
1781 if (tmp < 0) {
1782 speaker_id = tmp;
1783 break;
1784 }
1785 speaker_id |= tmp << i;
1786 }
1787 dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1788 }
1789 }
1790 return speaker_id;
1791 }
1792
cs35l41_hda_parse_acpi(struct cs35l41_hda * cs35l41,struct device * physdev,int id)1793 int cs35l41_hda_parse_acpi(struct cs35l41_hda *cs35l41, struct device *physdev, int id)
1794 {
1795 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1796 u32 values[HDA_MAX_COMPONENTS];
1797 char *property;
1798 size_t nval;
1799 int i, ret;
1800
1801 property = "cirrus,dev-index";
1802 ret = device_property_count_u32(physdev, property);
1803 if (ret <= 0)
1804 goto err;
1805
1806 if (ret > ARRAY_SIZE(values)) {
1807 ret = -EINVAL;
1808 goto err;
1809 }
1810 nval = ret;
1811
1812 ret = device_property_read_u32_array(physdev, property, values, nval);
1813 if (ret)
1814 goto err;
1815
1816 cs35l41->index = -1;
1817 for (i = 0; i < nval; i++) {
1818 if (values[i] == id) {
1819 cs35l41->index = i;
1820 break;
1821 }
1822 }
1823 if (cs35l41->index == -1) {
1824 dev_err(cs35l41->dev, "No index found in %s\n", property);
1825 ret = -ENODEV;
1826 goto err;
1827 }
1828
1829 /* To use the same release code for all laptop variants we can't use devm_ version of
1830 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node
1831 */
1832 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(cs35l41->dacpi), "reset",
1833 cs35l41->index, GPIOD_OUT_LOW,
1834 "cs35l41-reset");
1835
1836 property = "cirrus,speaker-position";
1837 ret = device_property_read_u32_array(physdev, property, values, nval);
1838 if (ret)
1839 goto err;
1840 hw_cfg->spk_pos = values[cs35l41->index];
1841
1842 cs35l41->channel_index = 0;
1843 for (i = 0; i < cs35l41->index; i++)
1844 if (values[i] == hw_cfg->spk_pos)
1845 cs35l41->channel_index++;
1846
1847 property = "cirrus,gpio1-func";
1848 ret = device_property_read_u32_array(physdev, property, values, nval);
1849 if (ret)
1850 goto err;
1851 hw_cfg->gpio1.func = values[cs35l41->index];
1852 hw_cfg->gpio1.valid = true;
1853
1854 property = "cirrus,gpio2-func";
1855 ret = device_property_read_u32_array(physdev, property, values, nval);
1856 if (ret)
1857 goto err;
1858 hw_cfg->gpio2.func = values[cs35l41->index];
1859 hw_cfg->gpio2.valid = true;
1860
1861 property = "cirrus,boost-peak-milliamp";
1862 ret = device_property_read_u32_array(physdev, property, values, nval);
1863 if (ret == 0)
1864 hw_cfg->bst_ipk = values[cs35l41->index];
1865 else
1866 hw_cfg->bst_ipk = -1;
1867
1868 property = "cirrus,boost-ind-nanohenry";
1869 ret = device_property_read_u32_array(physdev, property, values, nval);
1870 if (ret == 0)
1871 hw_cfg->bst_ind = values[cs35l41->index];
1872 else
1873 hw_cfg->bst_ind = -1;
1874
1875 property = "cirrus,boost-cap-microfarad";
1876 ret = device_property_read_u32_array(physdev, property, values, nval);
1877 if (ret == 0)
1878 hw_cfg->bst_cap = values[cs35l41->index];
1879 else
1880 hw_cfg->bst_cap = -1;
1881
1882 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1883
1884 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0)
1885 hw_cfg->bst_type = CS35L41_INT_BOOST;
1886 else
1887 hw_cfg->bst_type = CS35L41_EXT_BOOST;
1888
1889 hw_cfg->valid = true;
1890
1891 return 0;
1892 err:
1893 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1894 hw_cfg->valid = false;
1895 hw_cfg->gpio1.valid = false;
1896 hw_cfg->gpio2.valid = false;
1897 acpi_dev_put(cs35l41->dacpi);
1898
1899 return ret;
1900 }
1901
cs35l41_hda_read_acpi(struct cs35l41_hda * cs35l41,const char * hid,int id)1902 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1903 {
1904 struct acpi_device *adev;
1905 struct device *physdev;
1906 struct spi_device *spi;
1907 const char *sub;
1908 int ret;
1909
1910 adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1911 if (!adev) {
1912 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1913 return -ENODEV;
1914 }
1915
1916 cs35l41->dacpi = adev;
1917 physdev = get_device(acpi_get_first_physical_node(adev));
1918
1919 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev));
1920 if (IS_ERR(sub))
1921 sub = NULL;
1922 cs35l41->acpi_subsystem_id = sub;
1923
1924 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid);
1925 if (!ret) {
1926 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n");
1927 goto out;
1928 }
1929
1930 ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id);
1931 if (ret) {
1932 put_device(physdev);
1933 return ret;
1934 }
1935 out:
1936 put_device(physdev);
1937
1938 cs35l41->bypass_fw = false;
1939 if (cs35l41->control_bus == SPI) {
1940 spi = to_spi_device(cs35l41->dev);
1941 if (spi->max_speed_hz < CS35L41_MAX_ACCEPTABLE_SPI_SPEED_HZ) {
1942 dev_warn(cs35l41->dev,
1943 "SPI speed is too slow to support firmware download: %d Hz.\n",
1944 spi->max_speed_hz);
1945 cs35l41->bypass_fw = true;
1946 }
1947 }
1948
1949 return 0;
1950 }
1951
cs35l41_hda_probe(struct device * dev,const char * device_name,int id,int irq,struct regmap * regmap,enum control_bus control_bus)1952 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq,
1953 struct regmap *regmap, enum control_bus control_bus)
1954 {
1955 unsigned int regid, reg_revid;
1956 struct cs35l41_hda *cs35l41;
1957 int ret;
1958
1959 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs));
1960 BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ);
1961
1962 if (IS_ERR(regmap))
1963 return PTR_ERR(regmap);
1964
1965 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1966 if (!cs35l41)
1967 return -ENOMEM;
1968
1969 cs35l41->dev = dev;
1970 cs35l41->irq = irq;
1971 cs35l41->regmap = regmap;
1972 cs35l41->control_bus = control_bus;
1973 dev_set_drvdata(dev, cs35l41);
1974
1975 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1976 if (ret)
1977 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1978
1979 if (IS_ERR(cs35l41->reset_gpio)) {
1980 ret = PTR_ERR(cs35l41->reset_gpio);
1981 cs35l41->reset_gpio = NULL;
1982 if (ret == -EBUSY) {
1983 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1984 } else {
1985 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1986 goto err;
1987 }
1988 }
1989 if (cs35l41->reset_gpio) {
1990 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1991 usleep_range(2000, 2100);
1992 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1993 }
1994
1995 usleep_range(2000, 2100);
1996 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1997 usleep_range(2000, 2100);
1998
1999 ret = cs35l41_wait_boot_done(cs35l41);
2000 if (ret)
2001 goto err;
2002
2003 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
2004 if (ret)
2005 goto err;
2006
2007 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
2008 if (ret)
2009 goto err;
2010
2011 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
2012 if (ret)
2013 goto err;
2014
2015 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
2016 if (ret) {
2017 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
2018 goto err;
2019 }
2020
2021 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
2022 if (ret)
2023 goto err;
2024
2025 ret = cs35l41_get_calibration(cs35l41);
2026 if (ret && ret != -ENOENT)
2027 goto err;
2028
2029 cs35l41_mute(cs35l41->dev, true);
2030
2031 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
2032 mutex_init(&cs35l41->fw_mutex);
2033
2034 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
2035 pm_runtime_use_autosuspend(cs35l41->dev);
2036 pm_runtime_set_active(cs35l41->dev);
2037 pm_runtime_get_noresume(cs35l41->dev);
2038 pm_runtime_enable(cs35l41->dev);
2039
2040 ret = cs35l41_hda_apply_properties(cs35l41);
2041 if (ret)
2042 goto err_pm;
2043
2044 pm_runtime_put_autosuspend(cs35l41->dev);
2045
2046 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
2047 if (ret) {
2048 dev_err_probe(cs35l41->dev, ret, "Register component failed\n");
2049 goto err_pm;
2050 }
2051
2052 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
2053
2054 return 0;
2055
2056 err_pm:
2057 pm_runtime_dont_use_autosuspend(cs35l41->dev);
2058 pm_runtime_disable(cs35l41->dev);
2059 pm_runtime_put_noidle(cs35l41->dev);
2060
2061 err:
2062 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2063 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2064 gpiod_put(cs35l41->reset_gpio);
2065 gpiod_put(cs35l41->cs_gpio);
2066 acpi_dev_put(cs35l41->dacpi);
2067 kfree(cs35l41->acpi_subsystem_id);
2068
2069 return ret;
2070 }
2071 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, "SND_HDA_SCODEC_CS35L41");
2072
cs35l41_hda_remove(struct device * dev)2073 void cs35l41_hda_remove(struct device *dev)
2074 {
2075 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
2076
2077 component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
2078
2079 pm_runtime_get_sync(cs35l41->dev);
2080 pm_runtime_dont_use_autosuspend(cs35l41->dev);
2081 pm_runtime_disable(cs35l41->dev);
2082
2083 if (cs35l41->halo_initialized)
2084 cs35l41_remove_dsp(cs35l41);
2085
2086 acpi_dev_put(cs35l41->dacpi);
2087
2088 pm_runtime_put_noidle(cs35l41->dev);
2089
2090 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2091 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2092 gpiod_put(cs35l41->reset_gpio);
2093 gpiod_put(cs35l41->cs_gpio);
2094 kfree(cs35l41->acpi_subsystem_id);
2095 }
2096 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, "SND_HDA_SCODEC_CS35L41");
2097
2098 const struct dev_pm_ops cs35l41_hda_pm_ops = {
2099 RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume,
2100 cs35l41_runtime_idle)
2101 .prepare = cs35l41_system_suspend_prep,
2102 SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume)
2103 };
2104 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, "SND_HDA_SCODEC_CS35L41");
2105
2106 MODULE_DESCRIPTION("CS35L41 HDA Driver");
2107 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
2108 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
2109 MODULE_LICENSE("GPL");
2110 MODULE_IMPORT_NS("FW_CS_DSP");
2111 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw");
2112 MODULE_FIRMWARE("cirrus/cs35l41-*.bin");
2113