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;
184
185 cs35l56_hda_wait_dsp_ready(cs35l56);
186
187 regmap_read(cs35l56->base.regmap, kcontrol->private_value, ®_val);
188 reg_val &= CS35L56_ASP_TXn_SRC_MASK;
189
190 for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) {
191 if (cs35l56_tx_input_values[i] == reg_val) {
192 ucontrol->value.enumerated.item[0] = i;
193 break;
194 }
195 }
196
197 return 0;
198 }
199
cs35l56_hda_mixer_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)200 static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol,
201 struct snd_ctl_elem_value *ucontrol)
202 {
203 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
204 unsigned int item = ucontrol->value.enumerated.item[0];
205 bool changed;
206
207 if (item >= CS35L56_NUM_INPUT_SRC)
208 return -EINVAL;
209
210 cs35l56_hda_wait_dsp_ready(cs35l56);
211
212 regmap_update_bits_check(cs35l56->base.regmap, kcontrol->private_value,
213 CS35L56_INPUT_MASK, cs35l56_tx_input_values[item],
214 &changed);
215
216 return changed;
217 }
218
cs35l56_hda_posture_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)219 static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol,
220 struct snd_ctl_elem_info *uinfo)
221 {
222 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
223 uinfo->count = 1;
224 uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN;
225 uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX;
226 return 0;
227 }
228
cs35l56_hda_posture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)229 static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol,
230 struct snd_ctl_elem_value *ucontrol)
231 {
232 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
233 unsigned int pos;
234 int ret;
235
236 cs35l56_hda_wait_dsp_ready(cs35l56);
237
238 ret = regmap_read(cs35l56->base.regmap,
239 cs35l56->base.fw_reg->posture_number, &pos);
240 if (ret)
241 return ret;
242
243 ucontrol->value.integer.value[0] = pos;
244
245 return 0;
246 }
247
cs35l56_hda_posture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)248 static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol,
249 struct snd_ctl_elem_value *ucontrol)
250 {
251 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
252 unsigned long pos = ucontrol->value.integer.value[0];
253 bool changed;
254 int ret;
255
256 if ((pos < CS35L56_MAIN_POSTURE_MIN) ||
257 (pos > CS35L56_MAIN_POSTURE_MAX))
258 return -EINVAL;
259
260 cs35l56_hda_wait_dsp_ready(cs35l56);
261
262 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->posture_number,
263 CS35L56_MAIN_POSTURE_MASK, pos, &changed);
264 if (ret)
265 return ret;
266
267 return changed;
268 }
269
270 static const struct {
271 const char *name;
272 unsigned int reg;
273 } cs35l56_hda_mixer_controls[] = {
274 { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT },
275 { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT },
276 { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT },
277 { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT },
278 };
279
280 static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0);
281
cs35l56_hda_vol_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)282 static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol,
283 struct snd_ctl_elem_info *uinfo)
284 {
285 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
286 uinfo->count = 1;
287 uinfo->value.integer.step = 1;
288 uinfo->value.integer.min = 0;
289 uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
290 CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
291
292 return 0;
293 }
294
cs35l56_hda_vol_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)295 static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol,
296 struct snd_ctl_elem_value *ucontrol)
297 {
298 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
299 unsigned int raw_vol;
300 int vol;
301 int ret;
302
303 cs35l56_hda_wait_dsp_ready(cs35l56);
304
305 ret = regmap_read(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, &raw_vol);
306
307 if (ret)
308 return ret;
309
310 vol = (s16)(raw_vol & 0xFFFF);
311 vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
312
313 if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT))
314 vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1));
315
316 ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
317
318 return 0;
319 }
320
cs35l56_hda_vol_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)321 static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol,
322 struct snd_ctl_elem_value *ucontrol)
323 {
324 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
325 long vol = ucontrol->value.integer.value[0];
326 unsigned int raw_vol;
327 bool changed;
328 int ret;
329
330 if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
331 CS35L56_MAIN_RENDER_USER_VOLUME_MIN)))
332 return -EINVAL;
333
334 raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) <<
335 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
336
337 cs35l56_hda_wait_dsp_ready(cs35l56);
338
339 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume,
340 CS35L56_MAIN_RENDER_USER_VOLUME_MASK, raw_vol, &changed);
341 if (ret)
342 return ret;
343
344 return changed;
345 }
346
cs35l56_hda_create_controls(struct cs35l56_hda * cs35l56)347 static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)
348 {
349 struct snd_kcontrol_new ctl_template = {
350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
351 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
352 .info = cs35l56_hda_posture_info,
353 .get = cs35l56_hda_posture_get,
354 .put = cs35l56_hda_posture_put,
355 };
356 char name[64];
357 int i;
358
359 snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name);
360 ctl_template.name = name;
361 cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56);
362 if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl))
363 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
364
365 /* Mixer controls */
366 ctl_template.info = cs35l56_hda_mixer_info;
367 ctl_template.get = cs35l56_hda_mixer_get;
368 ctl_template.put = cs35l56_hda_mixer_put;
369
370 BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls));
371
372 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) {
373 snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name,
374 cs35l56_hda_mixer_controls[i].name);
375 ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg;
376 cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56);
377 if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) {
378 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n",
379 ctl_template.name);
380 }
381 }
382
383 ctl_template.info = cs35l56_hda_vol_info;
384 ctl_template.get = cs35l56_hda_vol_get;
385 ctl_template.put = cs35l56_hda_vol_put;
386 ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ);
387 ctl_template.tlv.p = cs35l56_hda_vol_tlv;
388 snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name);
389 ctl_template.name = name;
390 cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56);
391 if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl))
392 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
393 }
394
cs35l56_hda_remove_controls(struct cs35l56_hda * cs35l56)395 static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)
396 {
397 int i;
398
399 for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--)
400 snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]);
401
402 snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl);
403 snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl);
404 }
405
406 static const struct cs_dsp_client_ops cs35l56_hda_client_ops = {
407 /* cs_dsp requires the client to provide this even if it is empty */
408 };
409
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)410 static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56,
411 const struct firmware **firmware, char **filename,
412 const char *base_name, const char *system_name,
413 const char *amp_name,
414 const char *filetype)
415 {
416 char *s, c;
417 int ret = 0;
418
419 if (system_name && amp_name)
420 *filename = kasprintf(GFP_KERNEL, "%s-%s-%s.%s", base_name,
421 system_name, amp_name, filetype);
422 else if (system_name)
423 *filename = kasprintf(GFP_KERNEL, "%s-%s.%s", base_name,
424 system_name, filetype);
425 else
426 *filename = kasprintf(GFP_KERNEL, "%s.%s", base_name, filetype);
427
428 if (!*filename)
429 return -ENOMEM;
430
431 /*
432 * Make sure that filename is lower-case and any non alpha-numeric
433 * characters except full stop and forward slash are replaced with
434 * hyphens.
435 */
436 s = *filename;
437 while (*s) {
438 c = *s;
439 if (isalnum(c))
440 *s = tolower(c);
441 else if (c != '.' && c != '/')
442 *s = '-';
443 s++;
444 }
445
446 ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev);
447 if (ret) {
448 dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename);
449 kfree(*filename);
450 *filename = NULL;
451 return ret;
452 }
453
454 dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename);
455
456 return 0;
457 }
458
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)459 static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56,
460 unsigned int preloaded_fw_ver,
461 const struct firmware **wmfw_firmware,
462 char **wmfw_filename,
463 const struct firmware **coeff_firmware,
464 char **coeff_filename)
465 {
466 const char *system_name = cs35l56->system_name;
467 const char *amp_name = cs35l56->amp_name;
468 char base_name[37];
469 int ret;
470
471 if (preloaded_fw_ver) {
472 snprintf(base_name, sizeof(base_name),
473 "cirrus/cs35l%02x-%02x%s-%06x-dsp1-misc",
474 cs35l56->base.type,
475 cs35l56->base.rev,
476 cs35l56->base.secured ? "-s" : "",
477 preloaded_fw_ver & 0xffffff);
478 } else {
479 snprintf(base_name, sizeof(base_name),
480 "cirrus/cs35l%02x-%02x%s-dsp1-misc",
481 cs35l56->base.type,
482 cs35l56->base.rev,
483 cs35l56->base.secured ? "-s" : "");
484 }
485
486 if (system_name && amp_name) {
487 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
488 base_name, system_name, amp_name, "wmfw")) {
489 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
490 base_name, system_name, amp_name, "bin");
491 return;
492 }
493 }
494
495 if (system_name) {
496 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
497 base_name, system_name, NULL, "wmfw")) {
498 if (amp_name)
499 cs35l56_hda_request_firmware_file(cs35l56,
500 coeff_firmware, coeff_filename,
501 base_name, system_name,
502 amp_name, "bin");
503 if (!*coeff_firmware)
504 cs35l56_hda_request_firmware_file(cs35l56,
505 coeff_firmware, coeff_filename,
506 base_name, system_name,
507 NULL, "bin");
508 return;
509 }
510
511 /*
512 * Check for system-specific bin files without wmfw before
513 * falling back to generic firmware
514 */
515 if (amp_name)
516 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
517 base_name, system_name, amp_name, "bin");
518 if (!*coeff_firmware)
519 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
520 base_name, system_name, NULL, "bin");
521
522 if (*coeff_firmware)
523 return;
524 }
525
526 ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
527 base_name, NULL, NULL, "wmfw");
528 if (!ret) {
529 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
530 base_name, NULL, NULL, "bin");
531 return;
532 }
533
534 if (!*coeff_firmware)
535 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
536 base_name, NULL, NULL, "bin");
537 }
538
cs35l56_hda_release_firmware_files(const struct firmware * wmfw_firmware,char * wmfw_filename,const struct firmware * coeff_firmware,char * coeff_filename)539 static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware,
540 char *wmfw_filename,
541 const struct firmware *coeff_firmware,
542 char *coeff_filename)
543 {
544 release_firmware(wmfw_firmware);
545 kfree(wmfw_filename);
546
547 release_firmware(coeff_firmware);
548 kfree(coeff_filename);
549 }
550
cs35l56_hda_apply_calibration(struct cs35l56_hda * cs35l56)551 static void cs35l56_hda_apply_calibration(struct cs35l56_hda *cs35l56)
552 {
553 int ret;
554
555 if (!cs35l56->base.cal_data_valid || cs35l56->base.secured)
556 return;
557
558 ret = cs_amp_write_cal_coeffs(&cs35l56->cs_dsp,
559 &cs35l56_calibration_controls,
560 &cs35l56->base.cal_data);
561 if (ret < 0)
562 dev_warn(cs35l56->base.dev, "Failed to write calibration: %d\n", ret);
563 else
564 dev_info(cs35l56->base.dev, "Calibration applied\n");
565 }
566
cs35l56_hda_fw_load(struct cs35l56_hda * cs35l56)567 static void cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)
568 {
569 const struct firmware *coeff_firmware = NULL;
570 const struct firmware *wmfw_firmware = NULL;
571 char *coeff_filename = NULL;
572 char *wmfw_filename = NULL;
573 unsigned int preloaded_fw_ver;
574 bool firmware_missing;
575 int ret;
576
577 /*
578 * Prepare for a new DSP power-up. If the DSP has had firmware
579 * downloaded previously then it needs to be powered down so that it
580 * can be updated.
581 */
582 if (cs35l56->base.fw_patched)
583 cs_dsp_power_down(&cs35l56->cs_dsp);
584
585 cs35l56->base.fw_patched = false;
586
587 ret = pm_runtime_resume_and_get(cs35l56->base.dev);
588 if (ret < 0) {
589 dev_err(cs35l56->base.dev, "Failed to resume and get %d\n", ret);
590 return;
591 }
592
593 /*
594 * The firmware can only be upgraded if it is currently running
595 * from the built-in ROM. If not, the wmfw/bin must be for the
596 * version of firmware that is running on the chip.
597 */
598 ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &preloaded_fw_ver);
599 if (ret)
600 goto err_pm_put;
601
602 if (firmware_missing)
603 preloaded_fw_ver = 0;
604
605 cs35l56_hda_request_firmware_files(cs35l56, preloaded_fw_ver,
606 &wmfw_firmware, &wmfw_filename,
607 &coeff_firmware, &coeff_filename);
608
609 /*
610 * If the BIOS didn't patch the firmware a bin file is mandatory to
611 * enable the ASP·
612 */
613 if (!coeff_firmware && firmware_missing) {
614 dev_err(cs35l56->base.dev, ".bin file required but not found\n");
615 goto err_fw_release;
616 }
617
618 mutex_lock(&cs35l56->base.irq_lock);
619
620 /*
621 * If the firmware hasn't been patched it must be shutdown before
622 * doing a full patch and reset afterwards. If it is already
623 * running a patched version the firmware files only contain
624 * tunings and we can use the lower cost reinit sequence instead.
625 */
626 if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
627 ret = cs35l56_firmware_shutdown(&cs35l56->base);
628 if (ret)
629 goto err;
630 }
631
632 ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename,
633 coeff_firmware, coeff_filename, "misc");
634 if (ret) {
635 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret);
636 goto err;
637 }
638
639 if (wmfw_filename)
640 dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename);
641
642 if (coeff_filename)
643 dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename);
644
645 /* If we downloaded firmware, reset the device and wait for it to boot */
646 if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
647 cs35l56_system_reset(&cs35l56->base, false);
648 regcache_mark_dirty(cs35l56->base.regmap);
649 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
650 if (ret)
651 goto err_powered_up;
652
653 regcache_cache_only(cs35l56->base.regmap, false);
654 }
655
656 /* Disable auto-hibernate so that runtime_pm has control */
657 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
658 if (ret)
659 goto err_powered_up;
660
661 regcache_sync(cs35l56->base.regmap);
662
663 regmap_clear_bits(cs35l56->base.regmap,
664 cs35l56->base.fw_reg->prot_sts,
665 CS35L56_FIRMWARE_MISSING);
666 cs35l56->base.fw_patched = true;
667
668 ret = cs_dsp_run(&cs35l56->cs_dsp);
669 if (ret)
670 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
671
672 cs35l56_hda_apply_calibration(cs35l56);
673 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
674 if (ret)
675 cs_dsp_stop(&cs35l56->cs_dsp);
676
677 cs35l56_log_tuning(&cs35l56->base, &cs35l56->cs_dsp);
678
679 err_powered_up:
680 if (!cs35l56->base.fw_patched)
681 cs_dsp_power_down(&cs35l56->cs_dsp);
682 err:
683 mutex_unlock(&cs35l56->base.irq_lock);
684 err_fw_release:
685 cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename,
686 coeff_firmware, coeff_filename);
687 err_pm_put:
688 pm_runtime_put(cs35l56->base.dev);
689 }
690
cs35l56_hda_dsp_work(struct work_struct * work)691 static void cs35l56_hda_dsp_work(struct work_struct *work)
692 {
693 struct cs35l56_hda *cs35l56 = container_of(work, struct cs35l56_hda, dsp_work);
694
695 cs35l56_hda_fw_load(cs35l56);
696 }
697
cs35l56_hda_bind(struct device * dev,struct device * master,void * master_data)698 static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)
699 {
700 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
701 struct hda_component_parent *parent = master_data;
702 struct hda_component *comp;
703
704 comp = hda_component_from_index(parent, cs35l56->index);
705 if (!comp)
706 return -EINVAL;
707
708 if (comp->dev)
709 return -EBUSY;
710
711 comp->dev = dev;
712 cs35l56->codec = parent->codec;
713 strscpy(comp->name, dev_name(dev), sizeof(comp->name));
714 comp->playback_hook = cs35l56_hda_playback_hook;
715
716 queue_work(system_long_wq, &cs35l56->dsp_work);
717
718 cs35l56_hda_create_controls(cs35l56);
719
720 #if IS_ENABLED(CONFIG_SND_DEBUG)
721 cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root);
722 cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root);
723 #endif
724
725 dev_dbg(cs35l56->base.dev, "Bound\n");
726
727 return 0;
728 }
729
cs35l56_hda_unbind(struct device * dev,struct device * master,void * master_data)730 static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)
731 {
732 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
733 struct hda_component_parent *parent = master_data;
734 struct hda_component *comp;
735
736 cancel_work_sync(&cs35l56->dsp_work);
737
738 cs35l56_hda_remove_controls(cs35l56);
739
740 #if IS_ENABLED(CONFIG_SND_DEBUG)
741 cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp);
742 debugfs_remove_recursive(cs35l56->debugfs_root);
743 #endif
744
745 if (cs35l56->base.fw_patched)
746 cs_dsp_power_down(&cs35l56->cs_dsp);
747
748 comp = hda_component_from_index(parent, cs35l56->index);
749 if (comp && (comp->dev == dev))
750 memset(comp, 0, sizeof(*comp));
751
752 cs35l56->codec = NULL;
753
754 dev_dbg(cs35l56->base.dev, "Unbound\n");
755 }
756
757 static const struct component_ops cs35l56_hda_comp_ops = {
758 .bind = cs35l56_hda_bind,
759 .unbind = cs35l56_hda_unbind,
760 };
761
cs35l56_hda_system_suspend(struct device * dev)762 static int cs35l56_hda_system_suspend(struct device *dev)
763 {
764 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
765
766 cs35l56_hda_wait_dsp_ready(cs35l56);
767
768 if (cs35l56->playing)
769 cs35l56_hda_pause(cs35l56);
770
771 cs35l56->suspended = true;
772
773 /*
774 * The interrupt line is normally shared, but after we start suspending
775 * we can't check if our device is the source of an interrupt, and can't
776 * clear it. Prevent this race by temporarily disabling the parent irq
777 * until we reach _no_irq.
778 */
779 if (cs35l56->base.irq)
780 disable_irq(cs35l56->base.irq);
781
782 return pm_runtime_force_suspend(dev);
783 }
784
cs35l56_hda_system_suspend_late(struct device * dev)785 static int cs35l56_hda_system_suspend_late(struct device *dev)
786 {
787 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
788
789 /*
790 * RESET is usually shared by all amps so it must not be asserted until
791 * all driver instances have done their suspend() stage.
792 */
793 if (cs35l56->base.reset_gpio) {
794 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
795 cs35l56_wait_min_reset_pulse();
796 }
797
798 return 0;
799 }
800
cs35l56_hda_system_suspend_no_irq(struct device * dev)801 static int cs35l56_hda_system_suspend_no_irq(struct device *dev)
802 {
803 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
804
805 /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
806 if (cs35l56->base.irq)
807 enable_irq(cs35l56->base.irq);
808
809 return 0;
810 }
811
cs35l56_hda_system_resume_no_irq(struct device * dev)812 static int cs35l56_hda_system_resume_no_irq(struct device *dev)
813 {
814 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
815
816 /*
817 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
818 * spurious interrupts, and the interrupt line is normally shared.
819 * We can't check if our device is the source of an interrupt, and can't
820 * clear it, until it has fully resumed. Prevent this race by temporarily
821 * disabling the parent irq until we complete resume().
822 */
823 if (cs35l56->base.irq)
824 disable_irq(cs35l56->base.irq);
825
826 return 0;
827 }
828
cs35l56_hda_system_resume_early(struct device * dev)829 static int cs35l56_hda_system_resume_early(struct device *dev)
830 {
831 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
832
833 /* Ensure a spec-compliant RESET pulse. */
834 if (cs35l56->base.reset_gpio) {
835 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
836 cs35l56_wait_min_reset_pulse();
837
838 /* Release shared RESET before drivers start resume(). */
839 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
840 cs35l56_wait_control_port_ready();
841 }
842
843 return 0;
844 }
845
cs35l56_hda_system_resume(struct device * dev)846 static int cs35l56_hda_system_resume(struct device *dev)
847 {
848 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
849 int ret;
850
851 /* Undo pm_runtime_force_suspend() before re-enabling the irq */
852 ret = pm_runtime_force_resume(dev);
853 if (cs35l56->base.irq)
854 enable_irq(cs35l56->base.irq);
855
856 if (ret)
857 return ret;
858
859 cs35l56->suspended = false;
860
861 if (!cs35l56->codec)
862 return 0;
863
864 ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
865 dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
866 if (ret > 0)
867 queue_work(system_long_wq, &cs35l56->dsp_work);
868
869 if (cs35l56->playing)
870 cs35l56_hda_play(cs35l56);
871
872 return 0;
873 }
874
cs35l56_hda_fixup_yoga9(struct cs35l56_hda * cs35l56,int * bus_addr)875 static int cs35l56_hda_fixup_yoga9(struct cs35l56_hda *cs35l56, int *bus_addr)
876 {
877 /* The cirrus,dev-index property has the wrong values */
878 switch (*bus_addr) {
879 case 0x30:
880 cs35l56->index = 1;
881 return 0;
882 case 0x31:
883 cs35l56->index = 0;
884 return 0;
885 default:
886 /* There is a pseudo-address for broadcast to both amps - ignore it */
887 dev_dbg(cs35l56->base.dev, "Ignoring I2C address %#x\n", *bus_addr);
888 return 0;
889 }
890 }
891
892 static const struct {
893 const char *sub;
894 int (*fixup_fn)(struct cs35l56_hda *cs35l56, int *bus_addr);
895 } cs35l56_hda_fixups[] = {
896 {
897 .sub = "17AA390B", /* Lenovo Yoga Book 9i GenX */
898 .fixup_fn = cs35l56_hda_fixup_yoga9,
899 },
900 };
901
cs35l56_hda_apply_platform_fixups(struct cs35l56_hda * cs35l56,const char * sub,int * bus_addr)902 static int cs35l56_hda_apply_platform_fixups(struct cs35l56_hda *cs35l56, const char *sub,
903 int *bus_addr)
904 {
905 int i;
906
907 if (IS_ERR(sub))
908 return 0;
909
910 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_fixups); i++) {
911 if (strcasecmp(cs35l56_hda_fixups[i].sub, sub) == 0) {
912 dev_dbg(cs35l56->base.dev, "Applying fixup for %s\n",
913 cs35l56_hda_fixups[i].sub);
914 return (cs35l56_hda_fixups[i].fixup_fn)(cs35l56, bus_addr);
915 }
916 }
917
918 return 0;
919 }
920
cs35l56_hda_read_acpi(struct cs35l56_hda * cs35l56,int hid,int id)921 static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int hid, int id)
922 {
923 u32 values[HDA_MAX_COMPONENTS];
924 char hid_string[8];
925 struct acpi_device *adev;
926 const char *property, *sub;
927 size_t nval;
928 int i, ret;
929
930 /*
931 * ACPI_COMPANION isn't available when this driver was instantiated by
932 * the serial-multi-instantiate driver, so lookup the node by HID
933 */
934 if (!ACPI_COMPANION(cs35l56->base.dev)) {
935 snprintf(hid_string, sizeof(hid_string), "CSC%04X", hid);
936 adev = acpi_dev_get_first_match_dev(hid_string, NULL, -1);
937 if (!adev) {
938 dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n",
939 dev_name(cs35l56->base.dev));
940 return -ENODEV;
941 }
942 ACPI_COMPANION_SET(cs35l56->base.dev, adev);
943 }
944
945 /* Initialize things that could be overwritten by a fixup */
946 cs35l56->index = -1;
947
948 sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev));
949 ret = cs35l56_hda_apply_platform_fixups(cs35l56, sub, &id);
950 if (ret)
951 return ret;
952
953 if (cs35l56->index == -1) {
954 property = "cirrus,dev-index";
955 ret = device_property_count_u32(cs35l56->base.dev, property);
956 if (ret <= 0)
957 goto err;
958
959 if (ret > ARRAY_SIZE(values)) {
960 ret = -EINVAL;
961 goto err;
962 }
963 nval = ret;
964
965 ret = device_property_read_u32_array(cs35l56->base.dev, property, values, nval);
966 if (ret)
967 goto err;
968
969 for (i = 0; i < nval; i++) {
970 if (values[i] == id) {
971 cs35l56->index = i;
972 break;
973 }
974 }
975
976 /*
977 * It's not an error for the ID to be missing: for I2C there can be
978 * an alias address that is not a real device. So reject silently.
979 */
980 if (cs35l56->index == -1) {
981 dev_dbg(cs35l56->base.dev, "No index found in %s\n", property);
982 ret = -ENODEV;
983 goto err;
984 }
985 }
986
987 if (IS_ERR(sub)) {
988 dev_info(cs35l56->base.dev,
989 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n",
990 PTR_ERR(sub));
991 } else {
992 ret = cirrus_scodec_get_speaker_id(cs35l56->base.dev, cs35l56->index, nval, -1);
993 if (ret == -ENOENT) {
994 cs35l56->system_name = sub;
995 } else if (ret >= 0) {
996 cs35l56->system_name = kasprintf(GFP_KERNEL, "%s-spkid%d", sub, ret);
997 kfree(sub);
998 if (!cs35l56->system_name)
999 return -ENOMEM;
1000 } else {
1001 return ret;
1002 }
1003 }
1004
1005 cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev,
1006 "reset",
1007 cs35l56->index,
1008 GPIOD_OUT_LOW);
1009 if (IS_ERR(cs35l56->base.reset_gpio)) {
1010 ret = PTR_ERR(cs35l56->base.reset_gpio);
1011
1012 /*
1013 * If RESET is shared the first amp to probe will grab the reset
1014 * line and reset all the amps
1015 */
1016 if (ret != -EBUSY)
1017 return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
1018
1019 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
1020 cs35l56->base.reset_gpio = NULL;
1021 }
1022
1023 return 0;
1024
1025 err:
1026 if (ret != -ENODEV)
1027 dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret);
1028
1029 return ret;
1030 }
1031
cs35l56_hda_common_probe(struct cs35l56_hda * cs35l56,int hid,int id)1032 int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int hid, int id)
1033 {
1034 int ret;
1035
1036 mutex_init(&cs35l56->base.irq_lock);
1037 dev_set_drvdata(cs35l56->base.dev, cs35l56);
1038
1039 INIT_WORK(&cs35l56->dsp_work, cs35l56_hda_dsp_work);
1040
1041 ret = cs35l56_hda_read_acpi(cs35l56, hid, id);
1042 if (ret)
1043 goto err;
1044
1045 cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d",
1046 cs35l56->index + 1);
1047 if (!cs35l56->amp_name) {
1048 ret = -ENOMEM;
1049 goto err;
1050 }
1051
1052 cs35l56->base.cal_index = -1;
1053
1054 cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp);
1055 cs35l56->cs_dsp.client_ops = &cs35l56_hda_client_ops;
1056
1057 if (cs35l56->base.reset_gpio) {
1058 dev_dbg(cs35l56->base.dev, "Hard reset\n");
1059
1060 /*
1061 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the
1062 * ACPI defines a different default state. So explicitly set low.
1063 */
1064 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1065 cs35l56_wait_min_reset_pulse();
1066 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
1067 }
1068
1069 ret = cs35l56_hw_init(&cs35l56->base);
1070 if (ret < 0)
1071 goto err;
1072
1073 /* Reset the device and wait for it to boot */
1074 cs35l56_system_reset(&cs35l56->base, false);
1075 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
1076 if (ret)
1077 goto err;
1078
1079 regcache_cache_only(cs35l56->base.regmap, false);
1080
1081 ret = cs35l56_set_patch(&cs35l56->base);
1082 if (ret)
1083 goto err;
1084
1085 regcache_mark_dirty(cs35l56->base.regmap);
1086 regcache_sync(cs35l56->base.regmap);
1087
1088 /* Disable auto-hibernate so that runtime_pm has control */
1089 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
1090 if (ret)
1091 goto err;
1092
1093 ret = cs35l56_get_calibration(&cs35l56->base);
1094 if (ret)
1095 goto err;
1096
1097 ret = cs_dsp_halo_init(&cs35l56->cs_dsp);
1098 if (ret) {
1099 dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n");
1100 goto err;
1101 }
1102
1103 dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
1104 cs35l56->system_name, cs35l56->amp_name);
1105
1106 regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
1107 ARRAY_SIZE(cs35l56_hda_dai_config));
1108
1109 /*
1110 * By default only enable one ASP1TXn, where n=amplifier index,
1111 * This prevents multiple amps trying to drive the same slot.
1112 */
1113 cs35l56->asp_tx_mask = BIT(cs35l56->index);
1114
1115 pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000);
1116 pm_runtime_use_autosuspend(cs35l56->base.dev);
1117 pm_runtime_set_active(cs35l56->base.dev);
1118 pm_runtime_mark_last_busy(cs35l56->base.dev);
1119 pm_runtime_enable(cs35l56->base.dev);
1120
1121 cs35l56->base.init_done = true;
1122
1123 ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1124 if (ret) {
1125 dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
1126 goto pm_err;
1127 }
1128
1129 return 0;
1130
1131 pm_err:
1132 pm_runtime_disable(cs35l56->base.dev);
1133 cs_dsp_remove(&cs35l56->cs_dsp);
1134 err:
1135 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1136
1137 return ret;
1138 }
1139 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, "SND_HDA_SCODEC_CS35L56");
1140
cs35l56_hda_remove(struct device * dev)1141 void cs35l56_hda_remove(struct device *dev)
1142 {
1143 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
1144
1145 component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1146
1147 pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
1148 pm_runtime_get_sync(cs35l56->base.dev);
1149 pm_runtime_disable(cs35l56->base.dev);
1150
1151 cs_dsp_remove(&cs35l56->cs_dsp);
1152
1153 kfree(cs35l56->system_name);
1154 pm_runtime_put_noidle(cs35l56->base.dev);
1155
1156 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1157 }
1158 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, "SND_HDA_SCODEC_CS35L56");
1159
1160 const struct dev_pm_ops cs35l56_hda_pm_ops = {
1161 RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL)
1162 SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume)
1163 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late,
1164 cs35l56_hda_system_resume_early)
1165 NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq,
1166 cs35l56_hda_system_resume_no_irq)
1167 };
1168 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, "SND_HDA_SCODEC_CS35L56");
1169
1170 MODULE_DESCRIPTION("CS35L56 HDA Driver");
1171 MODULE_IMPORT_NS("FW_CS_DSP");
1172 MODULE_IMPORT_NS("SND_HDA_CIRRUS_SCODEC");
1173 MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED");
1174 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
1175 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
1176 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
1177 MODULE_LICENSE("GPL");
1178 MODULE_FIRMWARE("cirrus/cs35l54-*.wmfw");
1179 MODULE_FIRMWARE("cirrus/cs35l54-*.bin");
1180 MODULE_FIRMWARE("cirrus/cs35l56-*.wmfw");
1181 MODULE_FIRMWARE("cirrus/cs35l56-*.bin");
1182