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/hda_codec.h>
18 #include <sound/tlv.h>
19 #include "cs35l56_hda.h"
20 #include "hda_component.h"
21 #include "hda_cs_dsp_ctl.h"
22 #include "hda_generic.h"
23
24 /*
25 * The cs35l56_hda_dai_config[] reg sequence configures the device as
26 * ASP1_BCLK_FREQ = 3.072 MHz
27 * ASP1_RX_WIDTH = 32 cycles per slot, ASP1_TX_WIDTH = 32 cycles per slot, ASP1_FMT = I2S
28 * ASP1_DOUT_HIZ_CONTROL = Hi-Z during unused timeslots
29 * ASP1_RX_WL = 24 bits per sample
30 * ASP1_TX_WL = 24 bits per sample
31 * ASP1_RXn_EN 1..3 and ASP1_TXn_EN 1..4 disabled
32 */
33 static const struct reg_sequence cs35l56_hda_dai_config[] = {
34 { CS35L56_ASP1_CONTROL1, 0x00000021 },
35 { CS35L56_ASP1_CONTROL2, 0x20200200 },
36 { CS35L56_ASP1_CONTROL3, 0x00000003 },
37 { CS35L56_ASP1_DATA_CONTROL5, 0x00000018 },
38 { CS35L56_ASP1_DATA_CONTROL1, 0x00000018 },
39 { CS35L56_ASP1_ENABLES1, 0x00000000 },
40 };
41
cs35l56_hda_play(struct cs35l56_hda *cs35l56)42 static void cs35l56_hda_play(struct cs35l56_hda *cs35l56)
43 {
44 unsigned int val;
45 int ret;
46
47 pm_runtime_get_sync(cs35l56->base.dev);
48 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PLAY);
49 if (ret == 0) {
50 /* Wait for firmware to enter PS0 power state */
51 ret = regmap_read_poll_timeout(cs35l56->base.regmap,
52 CS35L56_TRANSDUCER_ACTUAL_PS,
53 val, (val == CS35L56_PS0),
54 CS35L56_PS0_POLL_US,
55 CS35L56_PS0_TIMEOUT_US);
56 if (ret)
57 dev_warn(cs35l56->base.dev, "PS0 wait failed: %d\n", ret);
58 }
59 regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
60 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
61 cs35l56->asp_tx_mask);
62 cs35l56->playing = true;
63 }
64
cs35l56_hda_pause(struct cs35l56_hda *cs35l56)65 static void cs35l56_hda_pause(struct cs35l56_hda *cs35l56)
66 {
67 cs35l56->playing = false;
68 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE);
69 regmap_clear_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
70 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
71 BIT(CS35L56_ASP_TX1_EN_SHIFT) | BIT(CS35L56_ASP_TX2_EN_SHIFT) |
72 BIT(CS35L56_ASP_TX3_EN_SHIFT) | BIT(CS35L56_ASP_TX4_EN_SHIFT));
73
74 pm_runtime_mark_last_busy(cs35l56->base.dev);
75 pm_runtime_put_autosuspend(cs35l56->base.dev);
76 }
77
cs35l56_hda_playback_hook(struct device *dev, int action)78 static void cs35l56_hda_playback_hook(struct device *dev, int action)
79 {
80 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
81
82 dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action);
83
84 switch (action) {
85 case HDA_GEN_PCM_ACT_PREPARE:
86 if (cs35l56->playing)
87 break;
88
89 /* If we're suspended: flag that resume should start playback */
90 if (cs35l56->suspended) {
91 cs35l56->playing = true;
92 break;
93 }
94
95 cs35l56_hda_play(cs35l56);
96 break;
97 case HDA_GEN_PCM_ACT_CLEANUP:
98 if (!cs35l56->playing)
99 break;
100
101 cs35l56_hda_pause(cs35l56);
102 break;
103 default:
104 break;
105 }
106 }
107
cs35l56_hda_runtime_suspend(struct device *dev)108 static int cs35l56_hda_runtime_suspend(struct device *dev)
109 {
110 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
111
112 if (cs35l56->cs_dsp.booted)
113 cs_dsp_stop(&cs35l56->cs_dsp);
114
115 return cs35l56_runtime_suspend_common(&cs35l56->base);
116 }
117
cs35l56_hda_runtime_resume(struct device *dev)118 static int cs35l56_hda_runtime_resume(struct device *dev)
119 {
120 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
121 int ret;
122
123 ret = cs35l56_runtime_resume_common(&cs35l56->base, false);
124 if (ret < 0)
125 return ret;
126
127 if (cs35l56->cs_dsp.booted) {
128 ret = cs_dsp_run(&cs35l56->cs_dsp);
129 if (ret) {
130 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
131 goto err;
132 }
133 }
134
135 return 0;
136
137 err:
138 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE);
139 regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1,
140 CS35L56_MBOX_CMD_HIBERNATE_NOW);
141
142 regcache_cache_only(cs35l56->base.regmap, true);
143
144 return ret;
145 }
146
cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)147 static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol,
148 struct snd_ctl_elem_info *uinfo)
149 {
150 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
151 uinfo->count = 1;
152 uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC;
153 if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC)
154 uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1;
155 strscpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item],
156 sizeof(uinfo->value.enumerated.name));
157
158 return 0;
159 }
160
cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)161 static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol,
162 struct snd_ctl_elem_value *ucontrol)
163 {
164 struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
165 unsigned int reg_val;
166 int i;
167
168 regmap_read(cs35l56->base.regmap, kcontrol->private_value, ®_val);
169 reg_val &= CS35L56_ASP_TXn_SRC_MASK;
170
171 for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) {
172 if (cs35l56_tx_input_values[i] == reg_val) {
173 ucontrol->value.enumerated.item[0] = i;
174 break;
175 }
176 }
177
178 return 0;
179 }
180
cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)181 static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol,
182 struct snd_ctl_elem_value *ucontrol)
183 {
184 struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
185 unsigned int item = ucontrol->value.enumerated.item[0];
186 bool changed;
187
188 if (item >= CS35L56_NUM_INPUT_SRC)
189 return -EINVAL;
190
191 regmap_update_bits_check(cs35l56->base.regmap, kcontrol->private_value,
192 CS35L56_INPUT_MASK, cs35l56_tx_input_values[item],
193 &changed);
194
195 return changed;
196 }
197
cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)198 static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol,
199 struct snd_ctl_elem_info *uinfo)
200 {
201 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
202 uinfo->count = 1;
203 uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN;
204 uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX;
205 return 0;
206 }
207
cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)208 static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol,
209 struct snd_ctl_elem_value *ucontrol)
210 {
211 struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
212 unsigned int pos;
213 int ret;
214
215 ret = regmap_read(cs35l56->base.regmap, CS35L56_MAIN_POSTURE_NUMBER, &pos);
216 if (ret)
217 return ret;
218
219 ucontrol->value.integer.value[0] = pos;
220
221 return 0;
222 }
223
cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)224 static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol,
225 struct snd_ctl_elem_value *ucontrol)
226 {
227 struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
228 unsigned long pos = ucontrol->value.integer.value[0];
229 bool changed;
230 int ret;
231
232 if ((pos < CS35L56_MAIN_POSTURE_MIN) ||
233 (pos > CS35L56_MAIN_POSTURE_MAX))
234 return -EINVAL;
235
236 ret = regmap_update_bits_check(cs35l56->base.regmap,
237 CS35L56_MAIN_POSTURE_NUMBER,
238 CS35L56_MAIN_POSTURE_MASK,
239 pos, &changed);
240 if (ret)
241 return ret;
242
243 return changed;
244 }
245
246 static const struct {
247 const char *name;
248 unsigned int reg;
249 } cs35l56_hda_mixer_controls[] = {
250 { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT },
251 { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT },
252 { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT },
253 { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT },
254 };
255
256 static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0);
257
cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)258 static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol,
259 struct snd_ctl_elem_info *uinfo)
260 {
261 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
262 uinfo->count = 1;
263 uinfo->value.integer.step = 1;
264 uinfo->value.integer.min = 0;
265 uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
266 CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
267
268 return 0;
269 }
270
cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)271 static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol,
272 struct snd_ctl_elem_value *ucontrol)
273 {
274 struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
275 unsigned int raw_vol;
276 int vol;
277 int ret;
278
279 ret = regmap_read(cs35l56->base.regmap, CS35L56_MAIN_RENDER_USER_VOLUME, &raw_vol);
280
281 if (ret)
282 return ret;
283
284 vol = (s16)(raw_vol & 0xFFFF);
285 vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
286
287 if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT))
288 vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1));
289
290 ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
291
292 return 0;
293 }
294
cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)295 static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol,
296 struct snd_ctl_elem_value *ucontrol)
297 {
298 struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
299 long vol = ucontrol->value.integer.value[0];
300 unsigned int raw_vol;
301 bool changed;
302 int ret;
303
304 if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
305 CS35L56_MAIN_RENDER_USER_VOLUME_MIN)))
306 return -EINVAL;
307
308 raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) <<
309 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
310
311 ret = regmap_update_bits_check(cs35l56->base.regmap,
312 CS35L56_MAIN_RENDER_USER_VOLUME,
313 CS35L56_MAIN_RENDER_USER_VOLUME_MASK,
314 raw_vol, &changed);
315 if (ret)
316 return ret;
317
318 return changed;
319 }
320
cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)321 static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)
322 {
323 struct snd_kcontrol_new ctl_template = {
324 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
325 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
326 .info = cs35l56_hda_posture_info,
327 .get = cs35l56_hda_posture_get,
328 .put = cs35l56_hda_posture_put,
329 };
330 char name[64];
331 int i;
332
333 snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name);
334 ctl_template.name = name;
335 cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56);
336 if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl))
337 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
338
339 /* Mixer controls */
340 ctl_template.info = cs35l56_hda_mixer_info;
341 ctl_template.get = cs35l56_hda_mixer_get;
342 ctl_template.put = cs35l56_hda_mixer_put;
343
344 BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls));
345
346 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) {
347 snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name,
348 cs35l56_hda_mixer_controls[i].name);
349 ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg;
350 cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56);
351 if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) {
352 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n",
353 ctl_template.name);
354 }
355 }
356
357 ctl_template.info = cs35l56_hda_vol_info;
358 ctl_template.get = cs35l56_hda_vol_get;
359 ctl_template.put = cs35l56_hda_vol_put;
360 ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ);
361 ctl_template.tlv.p = cs35l56_hda_vol_tlv;
362 snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name);
363 ctl_template.name = name;
364 cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56);
365 if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl))
366 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
367 }
368
cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)369 static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)
370 {
371 int i;
372
373 for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--)
374 snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]);
375
376 snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl);
377 snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl);
378 }
379
380 static const struct cs_dsp_client_ops cs35l56_hda_client_ops = {
381 .control_remove = hda_cs_dsp_control_remove,
382 };
383
cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56, const struct firmware **firmware, char **filename, const char *dir, const char *system_name, const char *amp_name, const char *filetype)384 static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56,
385 const struct firmware **firmware, char **filename,
386 const char *dir, const char *system_name,
387 const char *amp_name,
388 const char *filetype)
389 {
390 char *s, c;
391 int ret = 0;
392
393 if (system_name && amp_name)
394 *filename = kasprintf(GFP_KERNEL, "%scs35l56%s-%02x-dsp1-misc-%s-%s.%s", dir,
395 cs35l56->base.secured ? "s" : "", cs35l56->base.rev,
396 system_name, amp_name, filetype);
397 else if (system_name)
398 *filename = kasprintf(GFP_KERNEL, "%scs35l56%s-%02x-dsp1-misc-%s.%s", dir,
399 cs35l56->base.secured ? "s" : "", cs35l56->base.rev,
400 system_name, filetype);
401 else
402 *filename = kasprintf(GFP_KERNEL, "%scs35l56%s-%02x-dsp1-misc.%s", dir,
403 cs35l56->base.secured ? "s" : "", cs35l56->base.rev,
404 filetype);
405
406 if (!*filename)
407 return -ENOMEM;
408
409 /*
410 * Make sure that filename is lower-case and any non alpha-numeric
411 * characters except full stop and forward slash are replaced with
412 * hyphens.
413 */
414 s = *filename;
415 while (*s) {
416 c = *s;
417 if (isalnum(c))
418 *s = tolower(c);
419 else if (c != '.' && c != '/')
420 *s = '-';
421 s++;
422 }
423
424 ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev);
425 if (ret) {
426 dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename);
427 kfree(*filename);
428 *filename = NULL;
429 return ret;
430 }
431
432 dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename);
433
434 return 0;
435 }
436
437 static const char cirrus_dir[] = "cirrus/";
cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56, const struct firmware **wmfw_firmware, char **wmfw_filename, const struct firmware **coeff_firmware, char **coeff_filename)438 static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56,
439 const struct firmware **wmfw_firmware,
440 char **wmfw_filename,
441 const struct firmware **coeff_firmware,
442 char **coeff_filename)
443 {
444 const char *system_name = cs35l56->system_name;
445 const char *amp_name = cs35l56->amp_name;
446 int ret;
447
448 if (system_name && amp_name) {
449 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
450 cirrus_dir, system_name, amp_name, "wmfw")) {
451 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
452 cirrus_dir, system_name, amp_name, "bin");
453 return;
454 }
455 }
456
457 if (system_name) {
458 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
459 cirrus_dir, system_name, NULL, "wmfw")) {
460 if (amp_name)
461 cs35l56_hda_request_firmware_file(cs35l56,
462 coeff_firmware, coeff_filename,
463 cirrus_dir, system_name,
464 amp_name, "bin");
465 if (!*coeff_firmware)
466 cs35l56_hda_request_firmware_file(cs35l56,
467 coeff_firmware, coeff_filename,
468 cirrus_dir, system_name,
469 NULL, "bin");
470 return;
471 }
472 }
473
474 ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
475 cirrus_dir, NULL, NULL, "wmfw");
476 if (!ret) {
477 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
478 cirrus_dir, NULL, NULL, "bin");
479 return;
480 }
481
482 /* When a firmware file is not found must still search for the coeff files */
483 if (system_name) {
484 if (amp_name)
485 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
486 cirrus_dir, system_name, amp_name, "bin");
487 if (!*coeff_firmware)
488 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
489 cirrus_dir, system_name, NULL, "bin");
490 }
491
492 if (!*coeff_firmware)
493 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
494 cirrus_dir, NULL, NULL, "bin");
495 }
496
cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware, char *wmfw_filename, const struct firmware *coeff_firmware, char *coeff_filename)497 static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware,
498 char *wmfw_filename,
499 const struct firmware *coeff_firmware,
500 char *coeff_filename)
501 {
502 if (wmfw_firmware)
503 release_firmware(wmfw_firmware);
504 kfree(wmfw_filename);
505
506 if (coeff_firmware)
507 release_firmware(coeff_firmware);
508 kfree(coeff_filename);
509 }
510
cs35l56_hda_add_dsp_controls(struct cs35l56_hda *cs35l56)511 static void cs35l56_hda_add_dsp_controls(struct cs35l56_hda *cs35l56)
512 {
513 struct hda_cs_dsp_ctl_info info;
514
515 info.device_name = cs35l56->amp_name;
516 info.fw_type = HDA_CS_DSP_FW_MISC;
517 info.card = cs35l56->codec->card;
518
519 hda_cs_dsp_add_controls(&cs35l56->cs_dsp, &info);
520 }
521
cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)522 static int cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)
523 {
524 const struct firmware *coeff_firmware = NULL;
525 const struct firmware *wmfw_firmware = NULL;
526 char *coeff_filename = NULL;
527 char *wmfw_filename = NULL;
528 unsigned int firmware_missing;
529 int ret = 0;
530
531 /* Prepare for a new DSP power-up */
532 if (cs35l56->base.fw_patched)
533 cs_dsp_power_down(&cs35l56->cs_dsp);
534
535 cs35l56->base.fw_patched = false;
536
537 pm_runtime_get_sync(cs35l56->base.dev);
538
539 ret = regmap_read(cs35l56->base.regmap, CS35L56_PROTECTION_STATUS, &firmware_missing);
540 if (ret) {
541 dev_err(cs35l56->base.dev, "Failed to read PROTECTION_STATUS: %d\n", ret);
542 goto err_pm_put;
543 }
544
545 firmware_missing &= CS35L56_FIRMWARE_MISSING;
546
547 /*
548 * Firmware can only be downloaded if the CS35L56 is secured or is
549 * running from the built-in ROM. If it is secured the BIOS will have
550 * downloaded firmware, and the wmfw/bin files will only contain
551 * tunings that are safe to download with the firmware running.
552 */
553 if (cs35l56->base.secured || firmware_missing) {
554 cs35l56_hda_request_firmware_files(cs35l56, &wmfw_firmware, &wmfw_filename,
555 &coeff_firmware, &coeff_filename);
556 }
557
558 /*
559 * If the BIOS didn't patch the firmware a bin file is mandatory to
560 * enable the ASP·
561 */
562 if (!coeff_firmware && firmware_missing) {
563 dev_err(cs35l56->base.dev, ".bin file required but not found\n");
564 ret = -ENOENT;
565 goto err_fw_release;
566 }
567
568 mutex_lock(&cs35l56->base.irq_lock);
569
570 /*
571 * When the device is running in secure mode the firmware files can
572 * only contain insecure tunings and therefore we do not need to
573 * shutdown the firmware to apply them and can use the lower cost
574 * reinit sequence instead.
575 */
576 if (!cs35l56->base.secured && (wmfw_firmware || coeff_firmware)) {
577 ret = cs35l56_firmware_shutdown(&cs35l56->base);
578 if (ret)
579 goto err;
580 }
581
582 ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename,
583 coeff_firmware, coeff_filename, "misc");
584 if (ret) {
585 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret);
586 goto err;
587 }
588
589 if (wmfw_filename)
590 dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename);
591
592 if (coeff_filename)
593 dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename);
594
595 if (cs35l56->base.secured) {
596 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
597 if (ret)
598 goto err_powered_up;
599 } else if (wmfw_firmware || coeff_firmware) {
600 /* If we downloaded firmware, reset the device and wait for it to boot */
601 cs35l56_system_reset(&cs35l56->base, false);
602 regcache_mark_dirty(cs35l56->base.regmap);
603 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
604 if (ret)
605 goto err_powered_up;
606 }
607
608 /* Disable auto-hibernate so that runtime_pm has control */
609 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
610 if (ret)
611 goto err_powered_up;
612
613 regcache_sync(cs35l56->base.regmap);
614
615 regmap_clear_bits(cs35l56->base.regmap, CS35L56_PROTECTION_STATUS,
616 CS35L56_FIRMWARE_MISSING);
617 cs35l56->base.fw_patched = true;
618
619 ret = cs_dsp_run(&cs35l56->cs_dsp);
620 if (ret)
621 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
622
623 err_powered_up:
624 if (!cs35l56->base.fw_patched)
625 cs_dsp_power_down(&cs35l56->cs_dsp);
626 err:
627 mutex_unlock(&cs35l56->base.irq_lock);
628 err_fw_release:
629 cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename,
630 coeff_firmware, coeff_filename);
631 err_pm_put:
632 pm_runtime_put(cs35l56->base.dev);
633
634 return ret;
635 }
636
cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)637 static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)
638 {
639 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
640 struct hda_component *comps = master_data;
641 int ret;
642
643 if (!comps || cs35l56->index < 0 || cs35l56->index >= HDA_MAX_COMPONENTS)
644 return -EINVAL;
645
646 comps = &comps[cs35l56->index];
647 if (comps->dev)
648 return -EBUSY;
649
650 comps->dev = dev;
651 cs35l56->codec = comps->codec;
652 strscpy(comps->name, dev_name(dev), sizeof(comps->name));
653 comps->playback_hook = cs35l56_hda_playback_hook;
654
655 ret = cs35l56_hda_fw_load(cs35l56);
656 if (ret)
657 return ret;
658
659 cs35l56_hda_create_controls(cs35l56);
660 cs35l56_hda_add_dsp_controls(cs35l56);
661
662 #if IS_ENABLED(CONFIG_SND_DEBUG)
663 cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root);
664 cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root);
665 #endif
666
667 dev_dbg(cs35l56->base.dev, "Bound\n");
668
669 return 0;
670 }
671
cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)672 static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)
673 {
674 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
675 struct hda_component *comps = master_data;
676
677 cs35l56_hda_remove_controls(cs35l56);
678
679 #if IS_ENABLED(CONFIG_SND_DEBUG)
680 cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp);
681 debugfs_remove_recursive(cs35l56->debugfs_root);
682 #endif
683
684 if (cs35l56->base.fw_patched)
685 cs_dsp_power_down(&cs35l56->cs_dsp);
686
687 cs_dsp_remove(&cs35l56->cs_dsp);
688
689 if (comps[cs35l56->index].dev == dev)
690 memset(&comps[cs35l56->index], 0, sizeof(*comps));
691
692 dev_dbg(cs35l56->base.dev, "Unbound\n");
693 }
694
695 static const struct component_ops cs35l56_hda_comp_ops = {
696 .bind = cs35l56_hda_bind,
697 .unbind = cs35l56_hda_unbind,
698 };
699
cs35l56_hda_system_suspend(struct device *dev)700 static int cs35l56_hda_system_suspend(struct device *dev)
701 {
702 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
703
704 if (cs35l56->playing)
705 cs35l56_hda_pause(cs35l56);
706
707 cs35l56->suspended = true;
708
709 /*
710 * The interrupt line is normally shared, but after we start suspending
711 * we can't check if our device is the source of an interrupt, and can't
712 * clear it. Prevent this race by temporarily disabling the parent irq
713 * until we reach _no_irq.
714 */
715 if (cs35l56->base.irq)
716 disable_irq(cs35l56->base.irq);
717
718 return pm_runtime_force_suspend(dev);
719 }
720
cs35l56_hda_system_suspend_late(struct device *dev)721 static int cs35l56_hda_system_suspend_late(struct device *dev)
722 {
723 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
724
725 /*
726 * RESET is usually shared by all amps so it must not be asserted until
727 * all driver instances have done their suspend() stage.
728 */
729 if (cs35l56->base.reset_gpio) {
730 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
731 cs35l56_wait_min_reset_pulse();
732 }
733
734 return 0;
735 }
736
cs35l56_hda_system_suspend_no_irq(struct device *dev)737 static int cs35l56_hda_system_suspend_no_irq(struct device *dev)
738 {
739 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
740
741 /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
742 if (cs35l56->base.irq)
743 enable_irq(cs35l56->base.irq);
744
745 return 0;
746 }
747
cs35l56_hda_system_resume_no_irq(struct device *dev)748 static int cs35l56_hda_system_resume_no_irq(struct device *dev)
749 {
750 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
751
752 /*
753 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
754 * spurious interrupts, and the interrupt line is normally shared.
755 * We can't check if our device is the source of an interrupt, and can't
756 * clear it, until it has fully resumed. Prevent this race by temporarily
757 * disabling the parent irq until we complete resume().
758 */
759 if (cs35l56->base.irq)
760 disable_irq(cs35l56->base.irq);
761
762 return 0;
763 }
764
cs35l56_hda_system_resume_early(struct device *dev)765 static int cs35l56_hda_system_resume_early(struct device *dev)
766 {
767 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
768
769 /* Ensure a spec-compliant RESET pulse. */
770 if (cs35l56->base.reset_gpio) {
771 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
772 cs35l56_wait_min_reset_pulse();
773
774 /* Release shared RESET before drivers start resume(). */
775 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
776 cs35l56_wait_control_port_ready();
777 }
778
779 return 0;
780 }
781
cs35l56_hda_system_resume(struct device *dev)782 static int cs35l56_hda_system_resume(struct device *dev)
783 {
784 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
785 int ret;
786
787 /* Undo pm_runtime_force_suspend() before re-enabling the irq */
788 ret = pm_runtime_force_resume(dev);
789 if (cs35l56->base.irq)
790 enable_irq(cs35l56->base.irq);
791
792 if (ret)
793 return ret;
794
795 cs35l56->suspended = false;
796
797 ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
798 dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
799 if (ret > 0) {
800 ret = cs35l56_hda_fw_load(cs35l56);
801 if (ret)
802 return ret;
803 }
804
805 if (cs35l56->playing)
806 cs35l56_hda_play(cs35l56);
807
808 return 0;
809 }
810
cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int id)811 static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int id)
812 {
813 u32 values[HDA_MAX_COMPONENTS];
814 struct acpi_device *adev;
815 const char *property, *sub;
816 size_t nval;
817 int i, ret;
818
819 /*
820 * ACPI_COMPANION isn't available when this driver was instantiated by
821 * the serial-multi-instantiate driver, so lookup the node by HID
822 */
823 if (!ACPI_COMPANION(cs35l56->base.dev)) {
824 adev = acpi_dev_get_first_match_dev("CSC3556", NULL, -1);
825 if (!adev) {
826 dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n",
827 dev_name(cs35l56->base.dev));
828 return -ENODEV;
829 }
830 ACPI_COMPANION_SET(cs35l56->base.dev, adev);
831 }
832
833 property = "cirrus,dev-index";
834 ret = device_property_count_u32(cs35l56->base.dev, property);
835 if (ret <= 0)
836 goto err;
837
838 if (ret > ARRAY_SIZE(values)) {
839 ret = -EINVAL;
840 goto err;
841 }
842 nval = ret;
843
844 ret = device_property_read_u32_array(cs35l56->base.dev, property, values, nval);
845 if (ret)
846 goto err;
847
848 cs35l56->index = -1;
849 for (i = 0; i < nval; i++) {
850 if (values[i] == id) {
851 cs35l56->index = i;
852 break;
853 }
854 }
855 /*
856 * It's not an error for the ID to be missing: for I2C there can be
857 * an alias address that is not a real device. So reject silently.
858 */
859 if (cs35l56->index == -1) {
860 dev_dbg(cs35l56->base.dev, "No index found in %s\n", property);
861 ret = -ENODEV;
862 goto err;
863 }
864
865 sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev));
866
867 if (IS_ERR(sub)) {
868 dev_info(cs35l56->base.dev,
869 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n",
870 PTR_ERR(sub));
871 } else {
872 cs35l56->system_name = sub;
873 }
874
875 cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev,
876 "reset",
877 cs35l56->index,
878 GPIOD_OUT_LOW);
879 if (IS_ERR(cs35l56->base.reset_gpio)) {
880 ret = PTR_ERR(cs35l56->base.reset_gpio);
881
882 /*
883 * If RESET is shared the first amp to probe will grab the reset
884 * line and reset all the amps
885 */
886 if (ret != -EBUSY)
887 return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
888
889 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
890 cs35l56->base.reset_gpio = NULL;
891 }
892
893 return 0;
894
895 err:
896 if (ret != -ENODEV)
897 dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret);
898
899 return ret;
900 }
901
cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int id)902 int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int id)
903 {
904 int ret;
905
906 mutex_init(&cs35l56->base.irq_lock);
907 dev_set_drvdata(cs35l56->base.dev, cs35l56);
908
909 ret = cs35l56_hda_read_acpi(cs35l56, id);
910 if (ret)
911 goto err;
912
913 cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d",
914 cs35l56->index + 1);
915 if (!cs35l56->amp_name) {
916 ret = -ENOMEM;
917 goto err;
918 }
919
920 cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp);
921 cs35l56->cs_dsp.client_ops = &cs35l56_hda_client_ops;
922
923 if (cs35l56->base.reset_gpio) {
924 dev_dbg(cs35l56->base.dev, "Hard reset\n");
925
926 /*
927 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the
928 * ACPI defines a different default state. So explicitly set low.
929 */
930 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
931 cs35l56_wait_min_reset_pulse();
932 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
933 }
934
935 ret = cs35l56_hw_init(&cs35l56->base);
936 if (ret < 0)
937 goto err;
938
939 /* Reset the device and wait for it to boot */
940 cs35l56_system_reset(&cs35l56->base, false);
941 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
942 if (ret)
943 goto err;
944
945 ret = cs35l56_set_patch(&cs35l56->base);
946 if (ret)
947 goto err;
948
949 regcache_mark_dirty(cs35l56->base.regmap);
950 regcache_sync(cs35l56->base.regmap);
951
952 /* Disable auto-hibernate so that runtime_pm has control */
953 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
954 if (ret)
955 goto err;
956
957 ret = cs_dsp_halo_init(&cs35l56->cs_dsp);
958 if (ret) {
959 dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n");
960 goto err;
961 }
962
963 dev_dbg(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
964 cs35l56->system_name, cs35l56->amp_name);
965
966 regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
967 ARRAY_SIZE(cs35l56_hda_dai_config));
968
969 /*
970 * By default only enable one ASP1TXn, where n=amplifier index,
971 * This prevents multiple amps trying to drive the same slot.
972 */
973 cs35l56->asp_tx_mask = BIT(cs35l56->index);
974
975 pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000);
976 pm_runtime_use_autosuspend(cs35l56->base.dev);
977 pm_runtime_set_active(cs35l56->base.dev);
978 pm_runtime_mark_last_busy(cs35l56->base.dev);
979 pm_runtime_enable(cs35l56->base.dev);
980
981 ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
982 if (ret) {
983 dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
984 goto pm_err;
985 }
986
987 cs35l56->base.init_done = true;
988
989 return 0;
990
991 pm_err:
992 pm_runtime_disable(cs35l56->base.dev);
993 err:
994 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
995
996 return ret;
997 }
998 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, SND_HDA_SCODEC_CS35L56);
999
cs35l56_hda_remove(struct device *dev)1000 void cs35l56_hda_remove(struct device *dev)
1001 {
1002 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
1003
1004 pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
1005 pm_runtime_get_sync(cs35l56->base.dev);
1006 pm_runtime_disable(cs35l56->base.dev);
1007
1008 component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1009
1010 kfree(cs35l56->system_name);
1011 pm_runtime_put_noidle(cs35l56->base.dev);
1012
1013 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1014 }
1015 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, SND_HDA_SCODEC_CS35L56);
1016
1017 const struct dev_pm_ops cs35l56_hda_pm_ops = {
1018 RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL)
1019 SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume)
1020 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late,
1021 cs35l56_hda_system_resume_early)
1022 NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq,
1023 cs35l56_hda_system_resume_no_irq)
1024 };
1025 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, SND_HDA_SCODEC_CS35L56);
1026
1027 MODULE_DESCRIPTION("CS35L56 HDA Driver");
1028 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
1029 MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED);
1030 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
1031 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
1032 MODULE_LICENSE("GPL");
1033 MODULE_IMPORT_NS(FW_CS_DSP);
1034