xref: /linux/sound/hda/codecs/side-codecs/cs35l41_hda.c (revision 05a54fa773284d1a7923cdfdd8f0c8dabb98bd26)
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 
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 
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 
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 
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 
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 
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 
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 
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 
469 static void cs35l41_set_default_tuning_params(struct cs35l41_hda *cs35l41)
470 {
471 	cs35l41->tuning_gain = DEFAULT_AMP_GAIN_PCM;
472 }
473 
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 *)&params->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 
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 
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 
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 
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 */
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. */
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 
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 
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 
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 
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 
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 
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 
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 }
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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, &regid, &reg_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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 		mute = *ret->buffer.pointer;
1414 		dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute);
1415 	}
1416 
1417 	dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute);
1418 
1419 	return mute;
1420 }
1421 
1422 static void cs35l41_acpi_device_notify(acpi_handle handle, u32 event, struct device *dev)
1423 {
1424 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1425 	int mute;
1426 
1427 	if (event != CS35L41_NOTIFY_EVENT)
1428 		return;
1429 
1430 	mute = cs35l41_get_acpi_mute_state(cs35l41, handle);
1431 	if (mute < 0) {
1432 		dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute);
1433 		return;
1434 	}
1435 
1436 	dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute);
1437 	cs35l41->mute_override = (mute > 0);
1438 	cs35l41_mute(cs35l41->dev, cs35l41->mute_override);
1439 }
1440 
1441 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data)
1442 {
1443 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1444 	struct hda_component_parent *parent = master_data;
1445 	struct hda_component *comp;
1446 	unsigned int sleep_flags;
1447 	int ret = 0;
1448 
1449 	comp = hda_component_from_index(parent, cs35l41->index);
1450 	if (!comp)
1451 		return -EINVAL;
1452 
1453 	if (comp->dev)
1454 		return -EBUSY;
1455 
1456 	pm_runtime_get_sync(dev);
1457 
1458 	mutex_lock(&cs35l41->fw_mutex);
1459 
1460 	comp->dev = dev;
1461 	cs35l41->codec = parent->codec;
1462 	if (!cs35l41->acpi_subsystem_id)
1463 		cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1464 						       cs35l41->codec->core.subsystem_id);
1465 
1466 	strscpy(comp->name, dev_name(dev), sizeof(comp->name));
1467 
1468 	cs35l41->firmware_type = CS35L41_HDA_FW_SPK_PROT;
1469 
1470 	if (firmware_autostart) {
1471 		dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1472 		cs35l41->request_fw_load = true;
1473 		if (cs35l41_smart_amp(cs35l41) < 0)
1474 			dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1475 	} else {
1476 		dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1477 	}
1478 
1479 	ret = cs35l41_create_controls(cs35l41);
1480 
1481 	comp->playback_hook = cs35l41_hda_playback_hook;
1482 	comp->pre_playback_hook = cs35l41_hda_pre_playback_hook;
1483 	comp->post_playback_hook = cs35l41_hda_post_playback_hook;
1484 	comp->acpi_notify = cs35l41_acpi_device_notify;
1485 	comp->adev = cs35l41->dacpi;
1486 
1487 	comp->acpi_notifications_supported = cs35l41_dsm_supported(acpi_device_handle(comp->adev),
1488 		CS35L41_DSM_GET_MUTE);
1489 
1490 	cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41,
1491 						acpi_device_handle(cs35l41->dacpi)) > 0;
1492 
1493 	mutex_unlock(&cs35l41->fw_mutex);
1494 
1495 	sleep_flags = lock_system_sleep();
1496 	if (!device_link_add(&cs35l41->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
1497 		dev_warn(dev, "Unable to create device link\n");
1498 	unlock_system_sleep(sleep_flags);
1499 
1500 	pm_runtime_put_autosuspend(dev);
1501 
1502 	dev_info(cs35l41->dev,
1503 		 "CS35L41 Bound - SSID: %s, BST: %d, VSPK: %d, CH: %c, FW EN: %d, SPKID: %d\n",
1504 		 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type,
1505 		 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH,
1506 		 channel_name[cs35l41->hw_cfg.spk_pos],
1507 		 cs35l41->cs_dsp.running, cs35l41->speaker_id);
1508 
1509 	return ret;
1510 }
1511 
1512 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data)
1513 {
1514 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1515 	struct hda_component_parent *parent = master_data;
1516 	struct hda_component *comp;
1517 	unsigned int sleep_flags;
1518 
1519 	comp = hda_component_from_index(parent, cs35l41->index);
1520 	if (!comp)
1521 		return;
1522 
1523 	if (comp->dev == dev) {
1524 		sleep_flags = lock_system_sleep();
1525 		device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev);
1526 		unlock_system_sleep(sleep_flags);
1527 		memset(comp, 0, sizeof(*comp));
1528 	}
1529 }
1530 
1531 static const struct component_ops cs35l41_hda_comp_ops = {
1532 	.bind = cs35l41_hda_bind,
1533 	.unbind = cs35l41_hda_unbind,
1534 };
1535 
1536 static irqreturn_t cs35l41_bst_short_err(int irq, void *data)
1537 {
1538 	struct cs35l41_hda *cs35l41 = data;
1539 
1540 	dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1541 	set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1542 
1543 	return IRQ_HANDLED;
1544 }
1545 
1546 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data)
1547 {
1548 	struct cs35l41_hda *cs35l41 = data;
1549 
1550 	dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1551 	set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1552 
1553 	return IRQ_HANDLED;
1554 }
1555 
1556 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data)
1557 {
1558 	struct cs35l41_hda *cs35l41 = data;
1559 
1560 	dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1561 	set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1562 
1563 	return IRQ_HANDLED;
1564 }
1565 
1566 static irqreturn_t cs35l41_temp_err(int irq, void *data)
1567 {
1568 	struct cs35l41_hda *cs35l41 = data;
1569 
1570 	dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1571 	set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1572 
1573 	return IRQ_HANDLED;
1574 }
1575 
1576 static irqreturn_t cs35l41_temp_warn(int irq, void *data)
1577 {
1578 	struct cs35l41_hda *cs35l41 = data;
1579 
1580 	dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1581 	set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1582 
1583 	return IRQ_HANDLED;
1584 }
1585 
1586 static irqreturn_t cs35l41_amp_short(int irq, void *data)
1587 {
1588 	struct cs35l41_hda *cs35l41 = data;
1589 
1590 	dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1591 	set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1592 
1593 	return IRQ_HANDLED;
1594 }
1595 
1596 static const struct cs35l41_irq cs35l41_irqs[] = {
1597 	CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err),
1598 	CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err),
1599 	CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err),
1600 	CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn),
1601 	CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err),
1602 	CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short),
1603 };
1604 
1605 static const struct regmap_irq cs35l41_reg_irqs[] = {
1606 	CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR),
1607 	CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR),
1608 	CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR),
1609 	CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN),
1610 	CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR),
1611 	CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR),
1612 };
1613 
1614 static const struct regmap_irq_chip cs35l41_regmap_irq_chip = {
1615 	.name = "cs35l41 IRQ1 Controller",
1616 	.status_base = CS35L41_IRQ1_STATUS1,
1617 	.mask_base = CS35L41_IRQ1_MASK1,
1618 	.ack_base = CS35L41_IRQ1_STATUS1,
1619 	.num_regs = 4,
1620 	.irqs = cs35l41_reg_irqs,
1621 	.num_irqs = ARRAY_SIZE(cs35l41_reg_irqs),
1622 	.runtime_pm = true,
1623 };
1624 
1625 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol)
1626 {
1627 	int irq;
1628 	int ret;
1629 	int i;
1630 
1631 	if (!cs35l41->irq) {
1632 		dev_warn(cs35l41->dev, "No Interrupt Found");
1633 		goto err;
1634 	}
1635 
1636 	ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1637 					IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1638 					0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1639 	if (ret) {
1640 		dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret);
1641 		goto err;
1642 	}
1643 
1644 	for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) {
1645 		irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1646 		if (irq < 0) {
1647 			ret = irq;
1648 			dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name,
1649 				ret);
1650 			goto err;
1651 		}
1652 
1653 		ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1654 						cs35l41_irqs[i].handler,
1655 						IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1656 						cs35l41_irqs[i].name, cs35l41);
1657 		if (ret) {
1658 			dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.",
1659 				cs35l41_irqs[i].name, ret);
1660 			goto err;
1661 		}
1662 	}
1663 	return;
1664 err:
1665 	dev_warn(cs35l41->dev,
1666 		 "IRQ Config Failed. Amp errors may not be recoverable without reboot.");
1667 }
1668 
1669 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1670 {
1671 	struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1672 	bool using_irq = false;
1673 	int irq_pol;
1674 	int ret;
1675 
1676 	if (!cs35l41->hw_cfg.valid)
1677 		return -EINVAL;
1678 
1679 	ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1680 	if (ret)
1681 		return ret;
1682 
1683 	if (hw_cfg->gpio1.valid) {
1684 		switch (hw_cfg->gpio1.func) {
1685 		case CS35L41_NOT_USED:
1686 			break;
1687 		case CS35l41_VSPK_SWITCH:
1688 			hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO;
1689 			hw_cfg->gpio1.out_en = true;
1690 			break;
1691 		case CS35l41_SYNC:
1692 			hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC;
1693 			break;
1694 		default:
1695 			dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1696 				hw_cfg->gpio1.func);
1697 			return -EINVAL;
1698 		}
1699 	}
1700 
1701 	if (hw_cfg->gpio2.valid) {
1702 		switch (hw_cfg->gpio2.func) {
1703 		case CS35L41_NOT_USED:
1704 			break;
1705 		case CS35L41_INTERRUPT:
1706 			using_irq = true;
1707 			hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN;
1708 			break;
1709 		default:
1710 			dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1711 			return -EINVAL;
1712 		}
1713 	}
1714 
1715 	irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1716 
1717 	if (using_irq)
1718 		cs35l41_configure_interrupt(cs35l41, irq_pol);
1719 
1720 	return cs35l41_hda_channel_map(cs35l41);
1721 }
1722 
1723 int cs35l41_get_speaker_id(struct device *dev, int amp_index, int num_amps, int fixed_gpio_id)
1724 {
1725 	struct gpio_desc *speaker_id_desc;
1726 	int speaker_id = -ENODEV;
1727 
1728 	if (fixed_gpio_id >= 0) {
1729 		dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id);
1730 		speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN);
1731 		if (IS_ERR(speaker_id_desc)) {
1732 			speaker_id = PTR_ERR(speaker_id_desc);
1733 			return speaker_id;
1734 		}
1735 		speaker_id = gpiod_get_value_cansleep(speaker_id_desc);
1736 		gpiod_put(speaker_id_desc);
1737 		dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1738 	} else {
1739 		int base_index;
1740 		int gpios_per_amp;
1741 		int count;
1742 		int tmp;
1743 		int i;
1744 
1745 		count = gpiod_count(dev, "spk-id");
1746 		if (count > 0) {
1747 			speaker_id = 0;
1748 			gpios_per_amp = count / num_amps;
1749 			base_index = gpios_per_amp * amp_index;
1750 
1751 			if (count % num_amps)
1752 				return -EINVAL;
1753 
1754 			dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp);
1755 
1756 			for (i = 0; i < gpios_per_amp; i++) {
1757 				speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index,
1758 								  GPIOD_IN);
1759 				if (IS_ERR(speaker_id_desc)) {
1760 					speaker_id = PTR_ERR(speaker_id_desc);
1761 					break;
1762 				}
1763 				tmp = gpiod_get_value_cansleep(speaker_id_desc);
1764 				gpiod_put(speaker_id_desc);
1765 				if (tmp < 0) {
1766 					speaker_id = tmp;
1767 					break;
1768 				}
1769 				speaker_id |= tmp << i;
1770 			}
1771 			dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1772 		}
1773 	}
1774 	return speaker_id;
1775 }
1776 
1777 int cs35l41_hda_parse_acpi(struct cs35l41_hda *cs35l41, struct device *physdev, int id)
1778 {
1779 	struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1780 	u32 values[HDA_MAX_COMPONENTS];
1781 	char *property;
1782 	size_t nval;
1783 	int i, ret;
1784 
1785 	property = "cirrus,dev-index";
1786 	ret = device_property_count_u32(physdev, property);
1787 	if (ret <= 0)
1788 		goto err;
1789 
1790 	if (ret > ARRAY_SIZE(values)) {
1791 		ret = -EINVAL;
1792 		goto err;
1793 	}
1794 	nval = ret;
1795 
1796 	ret = device_property_read_u32_array(physdev, property, values, nval);
1797 	if (ret)
1798 		goto err;
1799 
1800 	cs35l41->index = -1;
1801 	for (i = 0; i < nval; i++) {
1802 		if (values[i] == id) {
1803 			cs35l41->index = i;
1804 			break;
1805 		}
1806 	}
1807 	if (cs35l41->index == -1) {
1808 		dev_err(cs35l41->dev, "No index found in %s\n", property);
1809 		ret = -ENODEV;
1810 		goto err;
1811 	}
1812 
1813 	/* To use the same release code for all laptop variants we can't use devm_ version of
1814 	 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node
1815 	 */
1816 	cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(cs35l41->dacpi), "reset",
1817 						     cs35l41->index, GPIOD_OUT_LOW,
1818 						     "cs35l41-reset");
1819 
1820 	property = "cirrus,speaker-position";
1821 	ret = device_property_read_u32_array(physdev, property, values, nval);
1822 	if (ret)
1823 		goto err;
1824 	hw_cfg->spk_pos = values[cs35l41->index];
1825 
1826 	cs35l41->channel_index = 0;
1827 	for (i = 0; i < cs35l41->index; i++)
1828 		if (values[i] == hw_cfg->spk_pos)
1829 			cs35l41->channel_index++;
1830 
1831 	property = "cirrus,gpio1-func";
1832 	ret = device_property_read_u32_array(physdev, property, values, nval);
1833 	if (ret)
1834 		goto err;
1835 	hw_cfg->gpio1.func = values[cs35l41->index];
1836 	hw_cfg->gpio1.valid = true;
1837 
1838 	property = "cirrus,gpio2-func";
1839 	ret = device_property_read_u32_array(physdev, property, values, nval);
1840 	if (ret)
1841 		goto err;
1842 	hw_cfg->gpio2.func = values[cs35l41->index];
1843 	hw_cfg->gpio2.valid = true;
1844 
1845 	property = "cirrus,boost-peak-milliamp";
1846 	ret = device_property_read_u32_array(physdev, property, values, nval);
1847 	if (ret == 0)
1848 		hw_cfg->bst_ipk = values[cs35l41->index];
1849 	else
1850 		hw_cfg->bst_ipk = -1;
1851 
1852 	property = "cirrus,boost-ind-nanohenry";
1853 	ret = device_property_read_u32_array(physdev, property, values, nval);
1854 	if (ret == 0)
1855 		hw_cfg->bst_ind = values[cs35l41->index];
1856 	else
1857 		hw_cfg->bst_ind = -1;
1858 
1859 	property = "cirrus,boost-cap-microfarad";
1860 	ret = device_property_read_u32_array(physdev, property, values, nval);
1861 	if (ret == 0)
1862 		hw_cfg->bst_cap = values[cs35l41->index];
1863 	else
1864 		hw_cfg->bst_cap = -1;
1865 
1866 	cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1867 
1868 	if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0)
1869 		hw_cfg->bst_type = CS35L41_INT_BOOST;
1870 	else
1871 		hw_cfg->bst_type = CS35L41_EXT_BOOST;
1872 
1873 	hw_cfg->valid = true;
1874 
1875 	return 0;
1876 err:
1877 	dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1878 	hw_cfg->valid = false;
1879 	hw_cfg->gpio1.valid = false;
1880 	hw_cfg->gpio2.valid = false;
1881 	acpi_dev_put(cs35l41->dacpi);
1882 
1883 	return ret;
1884 }
1885 
1886 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1887 {
1888 	struct acpi_device *adev;
1889 	struct device *physdev;
1890 	struct spi_device *spi;
1891 	const char *sub;
1892 	int ret;
1893 
1894 	adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1895 	if (!adev) {
1896 		dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1897 		return -ENODEV;
1898 	}
1899 
1900 	cs35l41->dacpi = adev;
1901 	physdev = get_device(acpi_get_first_physical_node(adev));
1902 
1903 	sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev));
1904 	if (IS_ERR(sub))
1905 		sub = NULL;
1906 	cs35l41->acpi_subsystem_id = sub;
1907 
1908 	ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid);
1909 	if (!ret) {
1910 		dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n");
1911 		goto out;
1912 	}
1913 
1914 	ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id);
1915 	if (ret) {
1916 		put_device(physdev);
1917 		return ret;
1918 	}
1919 out:
1920 	put_device(physdev);
1921 
1922 	cs35l41->bypass_fw = false;
1923 	if (cs35l41->control_bus == SPI) {
1924 		spi = to_spi_device(cs35l41->dev);
1925 		if (spi->max_speed_hz < CS35L41_MAX_ACCEPTABLE_SPI_SPEED_HZ) {
1926 			dev_warn(cs35l41->dev,
1927 				 "SPI speed is too slow to support firmware download: %d Hz.\n",
1928 				 spi->max_speed_hz);
1929 			cs35l41->bypass_fw = true;
1930 		}
1931 	}
1932 
1933 	return 0;
1934 }
1935 
1936 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq,
1937 		      struct regmap *regmap, enum control_bus control_bus)
1938 {
1939 	unsigned int regid, reg_revid;
1940 	struct cs35l41_hda *cs35l41;
1941 	int ret;
1942 
1943 	BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs));
1944 	BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ);
1945 
1946 	if (IS_ERR(regmap))
1947 		return PTR_ERR(regmap);
1948 
1949 	cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1950 	if (!cs35l41)
1951 		return -ENOMEM;
1952 
1953 	cs35l41->dev = dev;
1954 	cs35l41->irq = irq;
1955 	cs35l41->regmap = regmap;
1956 	cs35l41->control_bus = control_bus;
1957 	dev_set_drvdata(dev, cs35l41);
1958 
1959 	ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1960 	if (ret)
1961 		return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1962 
1963 	if (IS_ERR(cs35l41->reset_gpio)) {
1964 		ret = PTR_ERR(cs35l41->reset_gpio);
1965 		cs35l41->reset_gpio = NULL;
1966 		if (ret == -EBUSY) {
1967 			dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1968 		} else {
1969 			dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1970 			goto err;
1971 		}
1972 	}
1973 	if (cs35l41->reset_gpio) {
1974 		gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1975 		usleep_range(2000, 2100);
1976 		gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1977 	}
1978 
1979 	usleep_range(2000, 2100);
1980 	regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1981 	usleep_range(2000, 2100);
1982 
1983 	ret = cs35l41_wait_boot_done(cs35l41);
1984 	if (ret)
1985 		goto err;
1986 
1987 	ret = cs35l41_verify_id(cs35l41, &regid, &reg_revid);
1988 	if (ret)
1989 		goto err;
1990 
1991 	ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1992 	if (ret)
1993 		goto err;
1994 
1995 	ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1996 	if (ret)
1997 		goto err;
1998 
1999 	ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
2000 	if (ret) {
2001 		dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
2002 		goto err;
2003 	}
2004 
2005 	ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
2006 	if (ret)
2007 		goto err;
2008 
2009 	ret = cs35l41_get_calibration(cs35l41);
2010 	if (ret && ret != -ENOENT)
2011 		goto err;
2012 
2013 	cs35l41_mute(cs35l41->dev, true);
2014 
2015 	INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
2016 	mutex_init(&cs35l41->fw_mutex);
2017 
2018 	pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
2019 	pm_runtime_use_autosuspend(cs35l41->dev);
2020 	pm_runtime_set_active(cs35l41->dev);
2021 	pm_runtime_get_noresume(cs35l41->dev);
2022 	pm_runtime_enable(cs35l41->dev);
2023 
2024 	ret = cs35l41_hda_apply_properties(cs35l41);
2025 	if (ret)
2026 		goto err_pm;
2027 
2028 	pm_runtime_put_autosuspend(cs35l41->dev);
2029 
2030 	ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
2031 	if (ret) {
2032 		dev_err_probe(cs35l41->dev, ret, "Register component failed\n");
2033 		goto err_pm;
2034 	}
2035 
2036 	dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
2037 
2038 	return 0;
2039 
2040 err_pm:
2041 	pm_runtime_dont_use_autosuspend(cs35l41->dev);
2042 	pm_runtime_disable(cs35l41->dev);
2043 	pm_runtime_put_noidle(cs35l41->dev);
2044 
2045 err:
2046 	if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2047 		gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2048 	gpiod_put(cs35l41->reset_gpio);
2049 	gpiod_put(cs35l41->cs_gpio);
2050 	acpi_dev_put(cs35l41->dacpi);
2051 	kfree(cs35l41->acpi_subsystem_id);
2052 
2053 	return ret;
2054 }
2055 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, "SND_HDA_SCODEC_CS35L41");
2056 
2057 void cs35l41_hda_remove(struct device *dev)
2058 {
2059 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
2060 
2061 	component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
2062 
2063 	pm_runtime_get_sync(cs35l41->dev);
2064 	pm_runtime_dont_use_autosuspend(cs35l41->dev);
2065 	pm_runtime_disable(cs35l41->dev);
2066 
2067 	if (cs35l41->halo_initialized)
2068 		cs35l41_remove_dsp(cs35l41);
2069 
2070 	acpi_dev_put(cs35l41->dacpi);
2071 
2072 	pm_runtime_put_noidle(cs35l41->dev);
2073 
2074 	if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2075 		gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2076 	gpiod_put(cs35l41->reset_gpio);
2077 	gpiod_put(cs35l41->cs_gpio);
2078 	kfree(cs35l41->acpi_subsystem_id);
2079 }
2080 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, "SND_HDA_SCODEC_CS35L41");
2081 
2082 const struct dev_pm_ops cs35l41_hda_pm_ops = {
2083 	RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume,
2084 		       cs35l41_runtime_idle)
2085 	.prepare = cs35l41_system_suspend_prep,
2086 	SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume)
2087 };
2088 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, "SND_HDA_SCODEC_CS35L41");
2089 
2090 MODULE_DESCRIPTION("CS35L41 HDA Driver");
2091 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
2092 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
2093 MODULE_LICENSE("GPL");
2094 MODULE_IMPORT_NS("FW_CS_DSP");
2095 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw");
2096 MODULE_FIRMWARE("cirrus/cs35l41-*.bin");
2097