1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // HDA audio driver for Cirrus Logic CS35L56 smart amp
4 //
5 // Copyright (C) 2023 Cirrus Logic, Inc. and
6 // Cirrus Logic International Semiconductor Ltd.
7 //
8
9 #include <linux/acpi.h>
10 #include <linux/debugfs.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/module.h>
13 #include <linux/pm_runtime.h>
14 #include <linux/regmap.h>
15 #include <linux/slab.h>
16 #include <sound/core.h>
17 #include <sound/cs-amp-lib.h>
18 #include <sound/hda_codec.h>
19 #include <sound/tlv.h>
20 #include "cirrus_scodec.h"
21 #include "cs35l56_hda.h"
22 #include "hda_component.h"
23 #include "../generic.h"
24
25 /*
26 * The cs35l56_hda_dai_config[] reg sequence configures the device as
27 * ASP1_BCLK_FREQ = 3.072 MHz
28 * ASP1_RX_WIDTH = 32 cycles per slot, ASP1_TX_WIDTH = 32 cycles per slot, ASP1_FMT = I2S
29 * ASP1_DOUT_HIZ_CONTROL = Hi-Z during unused timeslots
30 * ASP1_RX_WL = 24 bits per sample
31 * ASP1_TX_WL = 24 bits per sample
32 * ASP1_RXn_EN 1..3 and ASP1_TXn_EN 1..4 disabled
33 *
34 * Override any Windows-specific mixer settings applied by the firmware.
35 */
36 static const struct reg_sequence cs35l56_hda_dai_config[] = {
37 { CS35L56_ASP1_CONTROL1, 0x00000021 },
38 { CS35L56_ASP1_CONTROL2, 0x20200200 },
39 { CS35L56_ASP1_CONTROL3, 0x00000003 },
40 { CS35L56_ASP1_FRAME_CONTROL1, 0x03020100 },
41 { CS35L56_ASP1_FRAME_CONTROL5, 0x00020100 },
42 { CS35L56_ASP1_DATA_CONTROL5, 0x00000018 },
43 { CS35L56_ASP1_DATA_CONTROL1, 0x00000018 },
44 { CS35L56_ASP1_ENABLES1, 0x00000000 },
45 { CS35L56_ASP1TX1_INPUT, 0x00000018 },
46 { CS35L56_ASP1TX2_INPUT, 0x00000019 },
47 { CS35L56_ASP1TX3_INPUT, 0x00000020 },
48 { CS35L56_ASP1TX4_INPUT, 0x00000028 },
49
50 };
51
cs35l56_hda_wait_dsp_ready(struct cs35l56_hda * cs35l56)52 static void cs35l56_hda_wait_dsp_ready(struct cs35l56_hda *cs35l56)
53 {
54 /* Wait for patching to complete */
55 flush_work(&cs35l56->dsp_work);
56 }
57
cs35l56_hda_play(struct cs35l56_hda * cs35l56)58 static void cs35l56_hda_play(struct cs35l56_hda *cs35l56)
59 {
60 unsigned int val;
61 int ret;
62
63 cs35l56_hda_wait_dsp_ready(cs35l56);
64
65 pm_runtime_get_sync(cs35l56->base.dev);
66 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PLAY);
67 if (ret == 0) {
68 /* Wait for firmware to enter PS0 power state */
69 ret = regmap_read_poll_timeout(cs35l56->base.regmap,
70 cs35l56->base.fw_reg->transducer_actual_ps,
71 val, (val == CS35L56_PS0),
72 CS35L56_PS0_POLL_US,
73 CS35L56_PS0_TIMEOUT_US);
74 if (ret)
75 dev_warn(cs35l56->base.dev, "PS0 wait failed: %d\n", ret);
76 }
77 regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
78 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
79 cs35l56->asp_tx_mask);
80 cs35l56->playing = true;
81 }
82
cs35l56_hda_pause(struct cs35l56_hda * cs35l56)83 static void cs35l56_hda_pause(struct cs35l56_hda *cs35l56)
84 {
85 cs35l56->playing = false;
86 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE);
87 regmap_clear_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
88 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
89 BIT(CS35L56_ASP_TX1_EN_SHIFT) | BIT(CS35L56_ASP_TX2_EN_SHIFT) |
90 BIT(CS35L56_ASP_TX3_EN_SHIFT) | BIT(CS35L56_ASP_TX4_EN_SHIFT));
91
92 pm_runtime_put_autosuspend(cs35l56->base.dev);
93 }
94
cs35l56_hda_playback_hook(struct device * dev,int action)95 static void cs35l56_hda_playback_hook(struct device *dev, int action)
96 {
97 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
98
99 dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action);
100
101 switch (action) {
102 case HDA_GEN_PCM_ACT_PREPARE:
103 if (cs35l56->playing)
104 break;
105
106 /* If we're suspended: flag that resume should start playback */
107 if (cs35l56->suspended) {
108 cs35l56->playing = true;
109 break;
110 }
111
112 cs35l56_hda_play(cs35l56);
113 break;
114 case HDA_GEN_PCM_ACT_CLEANUP:
115 if (!cs35l56->playing)
116 break;
117
118 cs35l56_hda_pause(cs35l56);
119 break;
120 default:
121 break;
122 }
123 }
124
cs35l56_hda_runtime_suspend(struct device * dev)125 static int cs35l56_hda_runtime_suspend(struct device *dev)
126 {
127 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
128
129 if (cs35l56->cs_dsp.booted)
130 cs_dsp_stop(&cs35l56->cs_dsp);
131
132 return cs35l56_runtime_suspend_common(&cs35l56->base);
133 }
134
cs35l56_hda_runtime_resume(struct device * dev)135 static int cs35l56_hda_runtime_resume(struct device *dev)
136 {
137 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
138 int ret;
139
140 ret = cs35l56_runtime_resume_common(&cs35l56->base, false);
141 if (ret < 0)
142 return ret;
143
144 if (cs35l56->cs_dsp.booted) {
145 ret = cs_dsp_run(&cs35l56->cs_dsp);
146 if (ret) {
147 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
148 goto err;
149 }
150 }
151
152 return 0;
153
154 err:
155 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE);
156 regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1,
157 CS35L56_MBOX_CMD_HIBERNATE_NOW);
158
159 regcache_cache_only(cs35l56->base.regmap, true);
160
161 return ret;
162 }
163
cs35l56_hda_mixer_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)164 static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol,
165 struct snd_ctl_elem_info *uinfo)
166 {
167 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
168 uinfo->count = 1;
169 uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC;
170 if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC)
171 uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1;
172 strscpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item],
173 sizeof(uinfo->value.enumerated.name));
174
175 return 0;
176 }
177
cs35l56_hda_mixer_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)178 static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol,
179 struct snd_ctl_elem_value *ucontrol)
180 {
181 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
182 unsigned int reg_val;
183 int i, ret;
184
185 cs35l56_hda_wait_dsp_ready(cs35l56);
186
187 ret = regmap_read(cs35l56->base.regmap, kcontrol->private_value,
188 ®_val);
189 if (ret)
190 return ret;
191
192 reg_val &= CS35L56_ASP_TXn_SRC_MASK;
193
194 for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) {
195 if (cs35l56_tx_input_values[i] == reg_val) {
196 ucontrol->value.enumerated.item[0] = i;
197 break;
198 }
199 }
200
201 return 0;
202 }
203
cs35l56_hda_mixer_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)204 static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol,
205 struct snd_ctl_elem_value *ucontrol)
206 {
207 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
208 unsigned int item = ucontrol->value.enumerated.item[0];
209 bool changed;
210 int ret;
211
212 if (item >= CS35L56_NUM_INPUT_SRC)
213 return -EINVAL;
214
215 cs35l56_hda_wait_dsp_ready(cs35l56);
216
217 ret = regmap_update_bits_check(cs35l56->base.regmap,
218 kcontrol->private_value,
219 CS35L56_INPUT_MASK,
220 cs35l56_tx_input_values[item],
221 &changed);
222 if (ret)
223 return ret;
224
225 return changed;
226 }
227
cs35l56_hda_posture_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)228 static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol,
229 struct snd_ctl_elem_info *uinfo)
230 {
231 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
232 uinfo->count = 1;
233 uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN;
234 uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX;
235 return 0;
236 }
237
cs35l56_hda_posture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)238 static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol,
239 struct snd_ctl_elem_value *ucontrol)
240 {
241 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
242 unsigned int pos;
243 int ret;
244
245 cs35l56_hda_wait_dsp_ready(cs35l56);
246
247 ret = regmap_read(cs35l56->base.regmap,
248 cs35l56->base.fw_reg->posture_number, &pos);
249 if (ret)
250 return ret;
251
252 ucontrol->value.integer.value[0] = pos;
253
254 return 0;
255 }
256
cs35l56_hda_posture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)257 static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol,
258 struct snd_ctl_elem_value *ucontrol)
259 {
260 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
261 long pos = ucontrol->value.integer.value[0];
262 bool changed;
263 int ret;
264
265 if ((pos < CS35L56_MAIN_POSTURE_MIN) ||
266 (pos > CS35L56_MAIN_POSTURE_MAX))
267 return -EINVAL;
268
269 cs35l56_hda_wait_dsp_ready(cs35l56);
270
271 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->posture_number,
272 CS35L56_MAIN_POSTURE_MASK, pos, &changed);
273 if (ret)
274 return ret;
275
276 return changed;
277 }
278
279 static const struct {
280 const char *name;
281 unsigned int reg;
282 } cs35l56_hda_mixer_controls[] = {
283 { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT },
284 { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT },
285 { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT },
286 { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT },
287 };
288
289 static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0);
290
cs35l56_hda_vol_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)291 static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol,
292 struct snd_ctl_elem_info *uinfo)
293 {
294 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
295 uinfo->count = 1;
296 uinfo->value.integer.step = 1;
297 uinfo->value.integer.min = 0;
298 uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
299 CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
300
301 return 0;
302 }
303
cs35l56_hda_vol_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)304 static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol,
305 struct snd_ctl_elem_value *ucontrol)
306 {
307 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
308 unsigned int raw_vol;
309 int vol;
310 int ret;
311
312 cs35l56_hda_wait_dsp_ready(cs35l56);
313
314 ret = regmap_read(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, &raw_vol);
315
316 if (ret)
317 return ret;
318
319 vol = (s16)(raw_vol & 0xFFFF);
320 vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
321
322 if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT))
323 vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1));
324
325 ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
326
327 return 0;
328 }
329
cs35l56_hda_vol_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)330 static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol,
331 struct snd_ctl_elem_value *ucontrol)
332 {
333 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
334 long vol = ucontrol->value.integer.value[0];
335 unsigned int raw_vol;
336 bool changed;
337 int ret;
338
339 if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
340 CS35L56_MAIN_RENDER_USER_VOLUME_MIN)))
341 return -EINVAL;
342
343 raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) <<
344 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
345
346 cs35l56_hda_wait_dsp_ready(cs35l56);
347
348 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume,
349 CS35L56_MAIN_RENDER_USER_VOLUME_MASK, raw_vol, &changed);
350 if (ret)
351 return ret;
352
353 return changed;
354 }
355
cs35l56_hda_create_controls(struct cs35l56_hda * cs35l56)356 static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)
357 {
358 struct snd_kcontrol_new ctl_template = {
359 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
360 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
361 .info = cs35l56_hda_posture_info,
362 .get = cs35l56_hda_posture_get,
363 .put = cs35l56_hda_posture_put,
364 };
365 char name[64];
366 int i;
367
368 snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name);
369 ctl_template.name = name;
370 cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56);
371 if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl))
372 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
373
374 /* Mixer controls */
375 ctl_template.info = cs35l56_hda_mixer_info;
376 ctl_template.get = cs35l56_hda_mixer_get;
377 ctl_template.put = cs35l56_hda_mixer_put;
378
379 BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls));
380
381 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) {
382 snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name,
383 cs35l56_hda_mixer_controls[i].name);
384 ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg;
385 cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56);
386 if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) {
387 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n",
388 ctl_template.name);
389 }
390 }
391
392 ctl_template.info = cs35l56_hda_vol_info;
393 ctl_template.get = cs35l56_hda_vol_get;
394 ctl_template.put = cs35l56_hda_vol_put;
395 ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ);
396 ctl_template.tlv.p = cs35l56_hda_vol_tlv;
397 snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name);
398 ctl_template.name = name;
399 cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56);
400 if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl))
401 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
402 }
403
cs35l56_hda_remove_controls(struct cs35l56_hda * cs35l56)404 static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)
405 {
406 int i;
407
408 for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--)
409 snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]);
410
411 snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl);
412 snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl);
413 }
414
cs35l56_hda_request_firmware_file(struct cs35l56_hda * cs35l56,const struct firmware ** firmware,char ** filename,const char * base_name,const char * system_name,const char * amp_name,const char * filetype)415 static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56,
416 const struct firmware **firmware, char **filename,
417 const char *base_name, const char *system_name,
418 const char *amp_name,
419 const char *filetype)
420 {
421 char *s, c;
422 int ret = 0;
423
424 if (system_name && amp_name)
425 *filename = kasprintf(GFP_KERNEL, "%s-%s-%s.%s", base_name,
426 system_name, amp_name, filetype);
427 else if (system_name)
428 *filename = kasprintf(GFP_KERNEL, "%s-%s.%s", base_name,
429 system_name, filetype);
430 else
431 *filename = kasprintf(GFP_KERNEL, "%s.%s", base_name, filetype);
432
433 if (!*filename)
434 return -ENOMEM;
435
436 /*
437 * Make sure that filename is lower-case and any non alpha-numeric
438 * characters except full stop and forward slash are replaced with
439 * hyphens.
440 */
441 s = *filename;
442 while (*s) {
443 c = *s;
444 if (isalnum(c))
445 *s = tolower(c);
446 else if (c != '.' && c != '/')
447 *s = '-';
448 s++;
449 }
450
451 ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev);
452 if (ret) {
453 dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename);
454 kfree(*filename);
455 *filename = NULL;
456 return ret;
457 }
458
459 dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename);
460
461 return 0;
462 }
463
cs35l56_hda_request_firmware_files(struct cs35l56_hda * cs35l56,unsigned int preloaded_fw_ver,const struct firmware ** wmfw_firmware,char ** wmfw_filename,const struct firmware ** coeff_firmware,char ** coeff_filename)464 static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56,
465 unsigned int preloaded_fw_ver,
466 const struct firmware **wmfw_firmware,
467 char **wmfw_filename,
468 const struct firmware **coeff_firmware,
469 char **coeff_filename)
470 {
471 const char *system_name = cs35l56->system_name;
472 const char *amp_name = cs35l56->amp_name;
473 char base_name[37];
474 int ret;
475
476 if (preloaded_fw_ver) {
477 snprintf(base_name, sizeof(base_name),
478 "cirrus/cs35l%02x-%02x%s-%06x-dsp1-misc",
479 cs35l56->base.type,
480 cs35l56->base.rev,
481 cs35l56->base.secured ? "-s" : "",
482 preloaded_fw_ver & 0xffffff);
483 } else {
484 snprintf(base_name, sizeof(base_name),
485 "cirrus/cs35l%02x-%02x%s-dsp1-misc",
486 cs35l56->base.type,
487 cs35l56->base.rev,
488 cs35l56->base.secured ? "-s" : "");
489 }
490
491 if (system_name && amp_name) {
492 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
493 base_name, system_name, amp_name, "wmfw")) {
494 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
495 base_name, system_name, amp_name, "bin");
496 return;
497 }
498 }
499
500 if (system_name) {
501 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
502 base_name, system_name, NULL, "wmfw")) {
503 if (amp_name)
504 cs35l56_hda_request_firmware_file(cs35l56,
505 coeff_firmware, coeff_filename,
506 base_name, system_name,
507 amp_name, "bin");
508 if (!*coeff_firmware)
509 cs35l56_hda_request_firmware_file(cs35l56,
510 coeff_firmware, coeff_filename,
511 base_name, system_name,
512 NULL, "bin");
513 return;
514 }
515
516 /*
517 * Check for system-specific bin files without wmfw before
518 * falling back to generic firmware
519 */
520 if (amp_name)
521 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
522 base_name, system_name, amp_name, "bin");
523 if (!*coeff_firmware)
524 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
525 base_name, system_name, NULL, "bin");
526
527 if (*coeff_firmware)
528 return;
529 }
530
531 ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
532 base_name, NULL, NULL, "wmfw");
533 if (!ret) {
534 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
535 base_name, NULL, NULL, "bin");
536 return;
537 }
538
539 if (!*coeff_firmware)
540 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
541 base_name, NULL, NULL, "bin");
542 }
543
cs35l56_hda_release_firmware_files(const struct firmware * wmfw_firmware,char * wmfw_filename,const struct firmware * coeff_firmware,char * coeff_filename)544 static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware,
545 char *wmfw_filename,
546 const struct firmware *coeff_firmware,
547 char *coeff_filename)
548 {
549 release_firmware(wmfw_firmware);
550 kfree(wmfw_filename);
551
552 release_firmware(coeff_firmware);
553 kfree(coeff_filename);
554 }
555
cs35l56_hda_apply_calibration(struct cs35l56_hda * cs35l56)556 static int cs35l56_hda_apply_calibration(struct cs35l56_hda *cs35l56)
557 {
558 int ret;
559
560 if (!cs35l56->base.cal_data_valid || cs35l56->base.secured)
561 return -EACCES;
562
563 ret = cs_amp_write_cal_coeffs(&cs35l56->cs_dsp,
564 &cs35l56_calibration_controls,
565 &cs35l56->base.cal_data);
566 if (ret < 0) {
567 dev_warn(cs35l56->base.dev, "Failed to write calibration: %d\n", ret);
568 return ret;
569 }
570
571 dev_info(cs35l56->base.dev, "Calibration applied\n");
572
573 return 0;
574 }
575
cs35l56_hda_fw_load(struct cs35l56_hda * cs35l56)576 static void cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)
577 {
578 const struct firmware *coeff_firmware = NULL;
579 const struct firmware *wmfw_firmware = NULL;
580 char *coeff_filename = NULL;
581 char *wmfw_filename = NULL;
582 unsigned int preloaded_fw_ver;
583 bool firmware_missing;
584 int ret;
585
586 /*
587 * Prepare for a new DSP power-up. If the DSP has had firmware
588 * downloaded previously then it needs to be powered down so that it
589 * can be updated.
590 */
591 if (cs35l56->base.fw_patched)
592 cs_dsp_power_down(&cs35l56->cs_dsp);
593
594 cs35l56->base.fw_patched = false;
595
596 PM_RUNTIME_ACQUIRE_IF_ENABLED(cs35l56->base.dev, pm);
597 ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
598 if (ret < 0) {
599 dev_err(cs35l56->base.dev, "Failed to resume and get %d\n", ret);
600 return;
601 }
602
603 /*
604 * The firmware can only be upgraded if it is currently running
605 * from the built-in ROM. If not, the wmfw/bin must be for the
606 * version of firmware that is running on the chip.
607 */
608 ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &preloaded_fw_ver);
609 if (ret)
610 return;
611
612 if (firmware_missing)
613 preloaded_fw_ver = 0;
614
615 cs35l56_hda_request_firmware_files(cs35l56, preloaded_fw_ver,
616 &wmfw_firmware, &wmfw_filename,
617 &coeff_firmware, &coeff_filename);
618
619 /*
620 * If the BIOS didn't patch the firmware a bin file is mandatory to
621 * enable the ASP·
622 */
623 if (!coeff_firmware && firmware_missing) {
624 dev_err(cs35l56->base.dev, ".bin file required but not found\n");
625 goto err_fw_release;
626 }
627
628 mutex_lock(&cs35l56->base.irq_lock);
629
630 /*
631 * If the firmware hasn't been patched it must be shutdown before
632 * doing a full patch and reset afterwards. If it is already
633 * running a patched version the firmware files only contain
634 * tunings and we can use the lower cost reinit sequence instead.
635 */
636 if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
637 ret = cs35l56_firmware_shutdown(&cs35l56->base);
638 if (ret)
639 goto err;
640 }
641
642 ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename,
643 coeff_firmware, coeff_filename, "misc");
644 if (ret) {
645 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret);
646 goto err;
647 }
648
649 if (wmfw_filename)
650 dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename);
651
652 if (coeff_filename)
653 dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename);
654
655 /* If we downloaded firmware, reset the device and wait for it to boot */
656 if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
657 cs35l56_system_reset(&cs35l56->base, false);
658 regcache_mark_dirty(cs35l56->base.regmap);
659 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
660 if (ret)
661 goto err_powered_up;
662
663 regcache_cache_only(cs35l56->base.regmap, false);
664 }
665
666 /* Disable auto-hibernate so that runtime_pm has control */
667 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
668 if (ret)
669 goto err_powered_up;
670
671 regcache_sync(cs35l56->base.regmap);
672
673 regmap_clear_bits(cs35l56->base.regmap,
674 cs35l56->base.fw_reg->prot_sts,
675 CS35L56_FIRMWARE_MISSING);
676 cs35l56->base.fw_patched = true;
677
678 ret = cs_dsp_run(&cs35l56->cs_dsp);
679 if (ret)
680 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
681
682 /* Don't need to check return code, it's not fatal if this fails */
683 cs35l56_hda_apply_calibration(cs35l56);
684
685 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
686 if (ret)
687 cs_dsp_stop(&cs35l56->cs_dsp);
688
689 cs35l56_log_tuning(&cs35l56->base, &cs35l56->cs_dsp);
690
691 err_powered_up:
692 if (!cs35l56->base.fw_patched)
693 cs_dsp_power_down(&cs35l56->cs_dsp);
694 err:
695 mutex_unlock(&cs35l56->base.irq_lock);
696 err_fw_release:
697 cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename,
698 coeff_firmware, coeff_filename);
699 }
700
cs35l56_hda_dsp_work(struct work_struct * work)701 static void cs35l56_hda_dsp_work(struct work_struct *work)
702 {
703 struct cs35l56_hda *cs35l56 = container_of(work, struct cs35l56_hda, dsp_work);
704
705 cs35l56_hda_fw_load(cs35l56);
706 }
707
cs35l56_hda_debugfs_calibrate_write(struct file * file,const char __user * from,size_t count,loff_t * ppos)708 static ssize_t cs35l56_hda_debugfs_calibrate_write(struct file *file,
709 const char __user *from,
710 size_t count, loff_t *ppos)
711 {
712 struct cs35l56_base *cs35l56_base = file->private_data;
713 ssize_t ret;
714
715 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm);
716 ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
717 if (ret)
718 return ret;
719
720 return cs35l56_calibrate_debugfs_write(cs35l56_base, from, count, ppos);
721 }
722
cs35l56_hda_debugfs_cal_temperature_write(struct file * file,const char __user * from,size_t count,loff_t * ppos)723 static ssize_t cs35l56_hda_debugfs_cal_temperature_write(struct file *file,
724 const char __user *from,
725 size_t count, loff_t *ppos)
726 {
727 struct cs35l56_base *cs35l56_base = file->private_data;
728 ssize_t ret;
729
730 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm);
731 ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
732 if (ret)
733 return ret;
734
735 return cs35l56_cal_ambient_debugfs_write(cs35l56_base, from, count, ppos);
736 }
737
cs35l56_hda_debugfs_cal_data_read(struct file * file,char __user * to,size_t count,loff_t * ppos)738 static ssize_t cs35l56_hda_debugfs_cal_data_read(struct file *file,
739 char __user *to,
740 size_t count, loff_t *ppos)
741 {
742 struct cs35l56_base *cs35l56_base = file->private_data;
743 ssize_t ret;
744
745 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm);
746 ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
747 if (ret)
748 return ret;
749
750 return cs35l56_cal_data_debugfs_read(cs35l56_base, to, count, ppos);
751 }
752
cs35l56_hda_debugfs_cal_data_write(struct file * file,const char __user * from,size_t count,loff_t * ppos)753 static ssize_t cs35l56_hda_debugfs_cal_data_write(struct file *file,
754 const char __user *from,
755 size_t count, loff_t *ppos)
756 {
757 struct cs35l56_base *cs35l56_base = file->private_data;
758 struct cs35l56_hda *cs35l56 = cs35l56_hda_from_base(cs35l56_base);
759 ssize_t ret;
760
761 ret = cs35l56_cal_data_debugfs_write(cs35l56_base, from, count, ppos);
762 if (ret == -ENODATA)
763 return count; /* Ignore writes of empty cal blobs */
764
765 if (ret < 0)
766 return ret;
767
768 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm);
769 ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
770 if (ret)
771 return ret;
772
773 ret = cs35l56_hda_apply_calibration(cs35l56);
774 if (ret == 0)
775 cs35l56_mbox_send(cs35l56_base, CS35L56_MBOX_CMD_AUDIO_REINIT);
776 else
777 count = -EIO;
778
779 return count;
780 }
781
782 static const struct cs35l56_cal_debugfs_fops cs35l56_hda_cal_debugfs_fops = {
783 .calibrate = {
784 .write = cs35l56_hda_debugfs_calibrate_write,
785 },
786 .cal_temperature = {
787 .write = cs35l56_hda_debugfs_cal_temperature_write,
788 },
789 .cal_data = {
790 .read = cs35l56_hda_debugfs_cal_data_read,
791 .write = cs35l56_hda_debugfs_cal_data_write,
792 },
793 };
794
cs35l56_hda_bind(struct device * dev,struct device * master,void * master_data)795 static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)
796 {
797 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
798 struct hda_component_parent *parent = master_data;
799 struct hda_component *comp;
800
801 comp = hda_component_from_index(parent, cs35l56->index);
802 if (!comp)
803 return -EINVAL;
804
805 if (comp->dev)
806 return -EBUSY;
807
808 comp->dev = dev;
809 cs35l56->codec = parent->codec;
810 strscpy(comp->name, dev_name(dev), sizeof(comp->name));
811 comp->playback_hook = cs35l56_hda_playback_hook;
812
813 queue_work(system_long_wq, &cs35l56->dsp_work);
814
815 cs35l56_hda_create_controls(cs35l56);
816
817 #if IS_ENABLED(CONFIG_SND_DEBUG)
818 cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root);
819 cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root);
820 #endif
821
822 if (IS_ENABLED(CONFIG_SND_HDA_SCODEC_CS35L56_CAL_DEBUGFS))
823 cs35l56_create_cal_debugfs(&cs35l56->base, &cs35l56_hda_cal_debugfs_fops);
824
825 dev_dbg(cs35l56->base.dev, "Bound\n");
826
827 return 0;
828 }
829
cs35l56_hda_unbind(struct device * dev,struct device * master,void * master_data)830 static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)
831 {
832 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
833 struct hda_component_parent *parent = master_data;
834 struct hda_component *comp;
835
836 cancel_work_sync(&cs35l56->dsp_work);
837
838 cs35l56_remove_cal_debugfs(&cs35l56->base);
839 cs35l56_hda_remove_controls(cs35l56);
840
841 #if IS_ENABLED(CONFIG_SND_DEBUG)
842 cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp);
843 debugfs_remove_recursive(cs35l56->debugfs_root);
844 #endif
845
846 if (cs35l56->base.fw_patched)
847 cs_dsp_power_down(&cs35l56->cs_dsp);
848
849 comp = hda_component_from_index(parent, cs35l56->index);
850 if (comp && (comp->dev == dev))
851 memset(comp, 0, sizeof(*comp));
852
853 cs35l56->codec = NULL;
854
855 dev_dbg(cs35l56->base.dev, "Unbound\n");
856 }
857
858 static const struct component_ops cs35l56_hda_comp_ops = {
859 .bind = cs35l56_hda_bind,
860 .unbind = cs35l56_hda_unbind,
861 };
862
cs35l56_hda_system_suspend(struct device * dev)863 static int cs35l56_hda_system_suspend(struct device *dev)
864 {
865 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
866
867 cs35l56_hda_wait_dsp_ready(cs35l56);
868
869 if (cs35l56->playing)
870 cs35l56_hda_pause(cs35l56);
871
872 cs35l56->suspended = true;
873
874 /*
875 * The interrupt line is normally shared, but after we start suspending
876 * we can't check if our device is the source of an interrupt, and can't
877 * clear it. Prevent this race by temporarily disabling the parent irq
878 * until we reach _no_irq.
879 */
880 if (cs35l56->base.irq)
881 disable_irq(cs35l56->base.irq);
882
883 return pm_runtime_force_suspend(dev);
884 }
885
cs35l56_hda_system_suspend_late(struct device * dev)886 static int cs35l56_hda_system_suspend_late(struct device *dev)
887 {
888 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
889
890 /*
891 * RESET is usually shared by all amps so it must not be asserted until
892 * all driver instances have done their suspend() stage.
893 */
894 if (cs35l56->base.reset_gpio) {
895 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
896 cs35l56_wait_min_reset_pulse();
897 }
898
899 return 0;
900 }
901
cs35l56_hda_system_suspend_no_irq(struct device * dev)902 static int cs35l56_hda_system_suspend_no_irq(struct device *dev)
903 {
904 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
905
906 /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
907 if (cs35l56->base.irq)
908 enable_irq(cs35l56->base.irq);
909
910 return 0;
911 }
912
cs35l56_hda_system_resume_no_irq(struct device * dev)913 static int cs35l56_hda_system_resume_no_irq(struct device *dev)
914 {
915 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
916
917 /*
918 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
919 * spurious interrupts, and the interrupt line is normally shared.
920 * We can't check if our device is the source of an interrupt, and can't
921 * clear it, until it has fully resumed. Prevent this race by temporarily
922 * disabling the parent irq until we complete resume().
923 */
924 if (cs35l56->base.irq)
925 disable_irq(cs35l56->base.irq);
926
927 return 0;
928 }
929
cs35l56_hda_system_resume_early(struct device * dev)930 static int cs35l56_hda_system_resume_early(struct device *dev)
931 {
932 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
933
934 /* Ensure a spec-compliant RESET pulse. */
935 if (cs35l56->base.reset_gpio) {
936 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
937 cs35l56_wait_min_reset_pulse();
938
939 /* Release shared RESET before drivers start resume(). */
940 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
941 cs35l56_wait_control_port_ready();
942 }
943
944 return 0;
945 }
946
cs35l56_hda_system_resume(struct device * dev)947 static int cs35l56_hda_system_resume(struct device *dev)
948 {
949 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
950 int ret;
951
952 /* Undo pm_runtime_force_suspend() before re-enabling the irq */
953 ret = pm_runtime_force_resume(dev);
954 if (cs35l56->base.irq)
955 enable_irq(cs35l56->base.irq);
956
957 if (ret)
958 return ret;
959
960 cs35l56->suspended = false;
961
962 if (!cs35l56->codec)
963 return 0;
964
965 ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
966 dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
967 if (ret > 0)
968 queue_work(system_long_wq, &cs35l56->dsp_work);
969
970 if (cs35l56->playing)
971 cs35l56_hda_play(cs35l56);
972
973 return 0;
974 }
975
cs35l56_hda_fixup_yoga9(struct cs35l56_hda * cs35l56,int * bus_addr)976 static int cs35l56_hda_fixup_yoga9(struct cs35l56_hda *cs35l56, int *bus_addr)
977 {
978 /* The cirrus,dev-index property has the wrong values */
979 cs35l56->num_amps = 2;
980 switch (*bus_addr) {
981 case 0x30:
982 cs35l56->index = 1;
983 return 0;
984 case 0x31:
985 cs35l56->index = 0;
986 return 0;
987 default:
988 /* There is a pseudo-address for broadcast to both amps - ignore it */
989 dev_dbg(cs35l56->base.dev, "Ignoring I2C address %#x\n", *bus_addr);
990 return 0;
991 }
992 }
993
994 static const struct {
995 const char *sub;
996 int (*fixup_fn)(struct cs35l56_hda *cs35l56, int *bus_addr);
997 } cs35l56_hda_fixups[] = {
998 {
999 .sub = "17AA390B", /* Lenovo Yoga Book 9i GenX */
1000 .fixup_fn = cs35l56_hda_fixup_yoga9,
1001 },
1002 };
1003
cs35l56_hda_apply_platform_fixups(struct cs35l56_hda * cs35l56,const char * sub,int * bus_addr)1004 static int cs35l56_hda_apply_platform_fixups(struct cs35l56_hda *cs35l56, const char *sub,
1005 int *bus_addr)
1006 {
1007 int i;
1008
1009 if (IS_ERR(sub))
1010 return 0;
1011
1012 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_fixups); i++) {
1013 if (strcasecmp(cs35l56_hda_fixups[i].sub, sub) == 0) {
1014 dev_dbg(cs35l56->base.dev, "Applying fixup for %s\n",
1015 cs35l56_hda_fixups[i].sub);
1016 return (cs35l56_hda_fixups[i].fixup_fn)(cs35l56, bus_addr);
1017 }
1018 }
1019
1020 return 0;
1021 }
1022
cs35l56_hda_read_acpi(struct cs35l56_hda * cs35l56,int hid,int id)1023 static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int hid, int id)
1024 {
1025 u32 values[HDA_MAX_COMPONENTS];
1026 char hid_string[8];
1027 struct acpi_device *adev;
1028 const char *property, *sub;
1029 int i, ret;
1030
1031 /*
1032 * ACPI_COMPANION isn't available when this driver was instantiated by
1033 * the serial-multi-instantiate driver, so lookup the node by HID
1034 */
1035 if (!ACPI_COMPANION(cs35l56->base.dev)) {
1036 snprintf(hid_string, sizeof(hid_string), "CSC%04X", hid);
1037 adev = acpi_dev_get_first_match_dev(hid_string, NULL, -1);
1038 if (!adev) {
1039 dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n",
1040 dev_name(cs35l56->base.dev));
1041 return -ENODEV;
1042 }
1043 ACPI_COMPANION_SET(cs35l56->base.dev, adev);
1044 acpi_dev_put(adev);
1045 }
1046
1047 /* Initialize things that could be overwritten by a fixup */
1048 cs35l56->index = -1;
1049
1050 sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev));
1051 ret = cs35l56_hda_apply_platform_fixups(cs35l56, sub, &id);
1052 if (ret)
1053 return ret;
1054
1055 if (cs35l56->index == -1) {
1056 property = "cirrus,dev-index";
1057 ret = device_property_count_u32(cs35l56->base.dev, property);
1058 if (ret <= 0)
1059 goto err;
1060
1061 if (ret > ARRAY_SIZE(values)) {
1062 ret = -EINVAL;
1063 goto err;
1064 }
1065 cs35l56->num_amps = ret;
1066
1067 ret = device_property_read_u32_array(cs35l56->base.dev, property, values,
1068 cs35l56->num_amps);
1069 if (ret)
1070 goto err;
1071
1072 for (i = 0; i < cs35l56->num_amps; i++) {
1073 if (values[i] == id) {
1074 cs35l56->index = i;
1075 break;
1076 }
1077 }
1078
1079 /*
1080 * It's not an error for the ID to be missing: for I2C there can be
1081 * an alias address that is not a real device. So reject silently.
1082 */
1083 if (cs35l56->index == -1) {
1084 dev_dbg(cs35l56->base.dev, "No index found in %s\n", property);
1085 ret = -ENODEV;
1086 goto err;
1087 }
1088 }
1089
1090 if (IS_ERR(sub)) {
1091 dev_info(cs35l56->base.dev,
1092 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n",
1093 PTR_ERR(sub));
1094 } else {
1095 ret = cirrus_scodec_get_speaker_id(cs35l56->base.dev, cs35l56->index,
1096 cs35l56->num_amps, -1);
1097 if (ret == -ENOENT) {
1098 cs35l56->system_name = sub;
1099 } else if (ret >= 0) {
1100 cs35l56->system_name = kasprintf(GFP_KERNEL, "%s-spkid%d", sub, ret);
1101 kfree(sub);
1102 if (!cs35l56->system_name)
1103 return -ENOMEM;
1104 } else {
1105 return ret;
1106 }
1107 }
1108
1109 cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev,
1110 "reset",
1111 cs35l56->index,
1112 GPIOD_OUT_LOW);
1113 if (IS_ERR(cs35l56->base.reset_gpio)) {
1114 ret = PTR_ERR(cs35l56->base.reset_gpio);
1115
1116 /*
1117 * If RESET is shared the first amp to probe will grab the reset
1118 * line and reset all the amps
1119 */
1120 if (ret != -EBUSY)
1121 return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
1122
1123 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
1124 cs35l56->base.reset_gpio = NULL;
1125 }
1126
1127 return 0;
1128
1129 err:
1130 if (ret != -ENODEV)
1131 dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret);
1132
1133 return ret;
1134 }
1135
cs35l56_hda_common_probe(struct cs35l56_hda * cs35l56,int hid,int id)1136 int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int hid, int id)
1137 {
1138 int ret;
1139
1140 mutex_init(&cs35l56->base.irq_lock);
1141 dev_set_drvdata(cs35l56->base.dev, cs35l56);
1142
1143 INIT_WORK(&cs35l56->dsp_work, cs35l56_hda_dsp_work);
1144
1145 ret = cs35l56_hda_read_acpi(cs35l56, hid, id);
1146 if (ret)
1147 goto err;
1148
1149 cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d",
1150 cs35l56->index + 1);
1151 if (!cs35l56->amp_name) {
1152 ret = -ENOMEM;
1153 goto err;
1154 }
1155
1156 cs35l56->base.type = hid & 0xff;
1157 cs35l56->base.cal_index = cs35l56->index;
1158
1159 cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp);
1160
1161 if (cs35l56->base.reset_gpio) {
1162 dev_dbg(cs35l56->base.dev, "Hard reset\n");
1163
1164 /*
1165 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the
1166 * ACPI defines a different default state. So explicitly set low.
1167 */
1168 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1169 cs35l56_wait_min_reset_pulse();
1170 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
1171 }
1172
1173 ret = cs35l56_hw_init(&cs35l56->base);
1174 if (ret < 0)
1175 goto err;
1176
1177 /* Reset the device and wait for it to boot */
1178 cs35l56_system_reset(&cs35l56->base, false);
1179 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
1180 if (ret)
1181 goto err;
1182
1183 regcache_cache_only(cs35l56->base.regmap, false);
1184
1185 ret = cs35l56_set_patch(&cs35l56->base);
1186 if (ret)
1187 goto err;
1188
1189 regcache_mark_dirty(cs35l56->base.regmap);
1190 regcache_sync(cs35l56->base.regmap);
1191
1192 /* Disable auto-hibernate so that runtime_pm has control */
1193 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
1194 if (ret)
1195 goto err;
1196
1197 ret = cs35l56_get_calibration(&cs35l56->base);
1198 if (ret)
1199 goto err;
1200
1201 ret = cs_dsp_halo_init(&cs35l56->cs_dsp);
1202 if (ret) {
1203 dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n");
1204 goto err;
1205 }
1206
1207 dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
1208 cs35l56->system_name, cs35l56->amp_name);
1209
1210 regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
1211 ARRAY_SIZE(cs35l56_hda_dai_config));
1212
1213 /*
1214 * By default only enable one ASP1TXn, where n=amplifier index,
1215 * This prevents multiple amps trying to drive the same slot.
1216 */
1217 cs35l56->asp_tx_mask = BIT(cs35l56->index);
1218
1219 pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000);
1220 pm_runtime_use_autosuspend(cs35l56->base.dev);
1221 pm_runtime_set_active(cs35l56->base.dev);
1222 pm_runtime_mark_last_busy(cs35l56->base.dev);
1223 pm_runtime_enable(cs35l56->base.dev);
1224
1225 cs35l56->base.init_done = true;
1226
1227 ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1228 if (ret) {
1229 dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
1230 goto pm_err;
1231 }
1232
1233 return 0;
1234
1235 pm_err:
1236 pm_runtime_disable(cs35l56->base.dev);
1237 cs_dsp_remove(&cs35l56->cs_dsp);
1238 err:
1239 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1240
1241 return ret;
1242 }
1243 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, "SND_HDA_SCODEC_CS35L56");
1244
cs35l56_hda_remove(struct device * dev)1245 void cs35l56_hda_remove(struct device *dev)
1246 {
1247 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
1248
1249 component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1250
1251 pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
1252 pm_runtime_get_sync(cs35l56->base.dev);
1253 pm_runtime_disable(cs35l56->base.dev);
1254
1255 cs_dsp_remove(&cs35l56->cs_dsp);
1256
1257 kfree(cs35l56->system_name);
1258 pm_runtime_put_noidle(cs35l56->base.dev);
1259
1260 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1261 }
1262 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, "SND_HDA_SCODEC_CS35L56");
1263
1264 const struct dev_pm_ops cs35l56_hda_pm_ops = {
1265 RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL)
1266 SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume)
1267 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late,
1268 cs35l56_hda_system_resume_early)
1269 NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq,
1270 cs35l56_hda_system_resume_no_irq)
1271 };
1272 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, "SND_HDA_SCODEC_CS35L56");
1273
1274 MODULE_DESCRIPTION("CS35L56 HDA Driver");
1275 MODULE_IMPORT_NS("FW_CS_DSP");
1276 MODULE_IMPORT_NS("SND_HDA_CIRRUS_SCODEC");
1277 MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED");
1278 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
1279 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
1280 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
1281 MODULE_LICENSE("GPL");
1282 MODULE_FIRMWARE("cirrus/cs35l54-*.wmfw");
1283 MODULE_FIRMWARE("cirrus/cs35l54-*.bin");
1284 MODULE_FIRMWARE("cirrus/cs35l56-*.wmfw");
1285 MODULE_FIRMWARE("cirrus/cs35l56-*.bin");
1286