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