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