1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * wm_adsp.c -- Wolfson ADSP support
4 *
5 * Copyright 2012 Wolfson Microelectronics plc
6 *
7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 */
9
10 #include <linux/ctype.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/init.h>
14 #include <linux/delay.h>
15 #include <linux/firmware.h>
16 #include <linux/list.h>
17 #include <linux/pm.h>
18 #include <linux/regmap.h>
19 #include <linux/regulator/consumer.h>
20 #include <linux/slab.h>
21 #include <linux/vmalloc.h>
22 #include <linux/workqueue.h>
23 #include <linux/debugfs.h>
24 #include <sound/core.h>
25 #include <sound/pcm.h>
26 #include <sound/pcm_params.h>
27 #include <sound/soc.h>
28 #include <sound/jack.h>
29 #include <sound/initval.h>
30 #include <sound/tlv.h>
31
32 #include "wm_adsp.h"
33
34 #define adsp_crit(_dsp, fmt, ...) \
35 dev_crit(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
36 #define adsp_err(_dsp, fmt, ...) \
37 dev_err(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
38 #define adsp_warn(_dsp, fmt, ...) \
39 dev_warn(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
40 #define adsp_info(_dsp, fmt, ...) \
41 dev_info(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
42 #define adsp_dbg(_dsp, fmt, ...) \
43 dev_dbg(_dsp->cs_dsp.dev, "%s: " fmt, _dsp->cs_dsp.name, ##__VA_ARGS__)
44
45 #define compr_err(_obj, fmt, ...) \
46 adsp_err(_obj->dsp, "%s: " fmt, _obj->name ? _obj->name : "legacy", \
47 ##__VA_ARGS__)
48 #define compr_dbg(_obj, fmt, ...) \
49 adsp_dbg(_obj->dsp, "%s: " fmt, _obj->name ? _obj->name : "legacy", \
50 ##__VA_ARGS__)
51
52 #define ADSP_MAX_STD_CTRL_SIZE 512
53
54 static const struct cs_dsp_client_ops wm_adsp1_client_ops;
55 static const struct cs_dsp_client_ops wm_adsp2_client_ops;
56
57 #define WM_ADSP_FW_MBC_VSS 0
58 #define WM_ADSP_FW_HIFI 1
59 #define WM_ADSP_FW_TX 2
60 #define WM_ADSP_FW_TX_SPK 3
61 #define WM_ADSP_FW_RX 4
62 #define WM_ADSP_FW_RX_ANC 5
63 #define WM_ADSP_FW_CTRL 6
64 #define WM_ADSP_FW_ASR 7
65 #define WM_ADSP_FW_TRACE 8
66 #define WM_ADSP_FW_SPK_PROT 9
67 #define WM_ADSP_FW_SPK_CALI 10
68 #define WM_ADSP_FW_SPK_DIAG 11
69 #define WM_ADSP_FW_MISC 12
70
71 #define WM_ADSP_NUM_FW 13
72
73 static const char *wm_adsp_fw_text[WM_ADSP_NUM_FW] = {
74 [WM_ADSP_FW_MBC_VSS] = "MBC/VSS",
75 [WM_ADSP_FW_HIFI] = "MasterHiFi",
76 [WM_ADSP_FW_TX] = "Tx",
77 [WM_ADSP_FW_TX_SPK] = "Tx Speaker",
78 [WM_ADSP_FW_RX] = "Rx",
79 [WM_ADSP_FW_RX_ANC] = "Rx ANC",
80 [WM_ADSP_FW_CTRL] = "Voice Ctrl",
81 [WM_ADSP_FW_ASR] = "ASR Assist",
82 [WM_ADSP_FW_TRACE] = "Dbg Trace",
83 [WM_ADSP_FW_SPK_PROT] = "Protection",
84 [WM_ADSP_FW_SPK_CALI] = "Calibration",
85 [WM_ADSP_FW_SPK_DIAG] = "Diagnostic",
86 [WM_ADSP_FW_MISC] = "Misc",
87 };
88
89 struct wm_adsp_system_config_xm_hdr {
90 __be32 sys_enable;
91 __be32 fw_id;
92 __be32 fw_rev;
93 __be32 boot_status;
94 __be32 watchdog;
95 __be32 dma_buffer_size;
96 __be32 rdma[6];
97 __be32 wdma[8];
98 __be32 build_job_name[3];
99 __be32 build_job_number;
100 } __packed;
101
102 struct wm_halo_system_config_xm_hdr {
103 __be32 halo_heartbeat;
104 __be32 build_job_name[3];
105 __be32 build_job_number;
106 } __packed;
107
108 struct wm_adsp_alg_xm_struct {
109 __be32 magic;
110 __be32 smoothing;
111 __be32 threshold;
112 __be32 host_buf_ptr;
113 __be32 start_seq;
114 __be32 high_water_mark;
115 __be32 low_water_mark;
116 __be64 smoothed_power;
117 } __packed;
118
119 struct wm_adsp_host_buf_coeff_v1 {
120 __be32 host_buf_ptr; /* Host buffer pointer */
121 __be32 versions; /* Version numbers */
122 __be32 name[4]; /* The buffer name */
123 } __packed;
124
125 struct wm_adsp_buffer {
126 __be32 buf1_base; /* Base addr of first buffer area */
127 __be32 buf1_size; /* Size of buf1 area in DSP words */
128 __be32 buf2_base; /* Base addr of 2nd buffer area */
129 __be32 buf1_buf2_size; /* Size of buf1+buf2 in DSP words */
130 __be32 buf3_base; /* Base addr of buf3 area */
131 __be32 buf_total_size; /* Size of buf1+buf2+buf3 in DSP words */
132 __be32 high_water_mark; /* Point at which IRQ is asserted */
133 __be32 irq_count; /* bits 1-31 count IRQ assertions */
134 __be32 irq_ack; /* acked IRQ count, bit 0 enables IRQ */
135 __be32 next_write_index; /* word index of next write */
136 __be32 next_read_index; /* word index of next read */
137 __be32 error; /* error if any */
138 __be32 oldest_block_index; /* word index of oldest surviving */
139 __be32 requested_rewind; /* how many blocks rewind was done */
140 __be32 reserved_space; /* internal */
141 __be32 min_free; /* min free space since stream start */
142 __be32 blocks_written[2]; /* total blocks written (64 bit) */
143 __be32 words_written[2]; /* total words written (64 bit) */
144 } __packed;
145
146 struct wm_adsp_compr;
147
148 struct wm_adsp_compr_buf {
149 struct list_head list;
150 struct wm_adsp *dsp;
151 struct wm_adsp_compr *compr;
152
153 struct wm_adsp_buffer_region *regions;
154 u32 host_buf_ptr;
155
156 u32 error;
157 u32 irq_count;
158 int read_index;
159 int avail;
160 int host_buf_mem_type;
161
162 char *name;
163 };
164
165 struct wm_adsp_compr {
166 struct list_head list;
167 struct wm_adsp *dsp;
168 struct wm_adsp_compr_buf *buf;
169
170 struct snd_compr_stream *stream;
171 struct snd_compressed_buffer size;
172
173 u32 *raw_buf;
174 unsigned int copied_total;
175
176 unsigned int sample_rate;
177
178 const char *name;
179 };
180
181 #define WM_ADSP_MIN_FRAGMENTS 1
182 #define WM_ADSP_MAX_FRAGMENTS 256
183 #define WM_ADSP_MIN_FRAGMENT_SIZE (16 * CS_DSP_DATA_WORD_SIZE)
184 #define WM_ADSP_MAX_FRAGMENT_SIZE (4096 * CS_DSP_DATA_WORD_SIZE)
185
186 #define WM_ADSP_ALG_XM_STRUCT_MAGIC 0x49aec7
187
188 #define HOST_BUFFER_FIELD(field) \
189 (offsetof(struct wm_adsp_buffer, field) / sizeof(__be32))
190
191 #define ALG_XM_FIELD(field) \
192 (offsetof(struct wm_adsp_alg_xm_struct, field) / sizeof(__be32))
193
194 #define HOST_BUF_COEFF_SUPPORTED_COMPAT_VER 1
195
196 #define HOST_BUF_COEFF_COMPAT_VER_MASK 0xFF00
197 #define HOST_BUF_COEFF_COMPAT_VER_SHIFT 8
198
199 static int wm_adsp_buffer_init(struct wm_adsp *dsp);
200 static int wm_adsp_buffer_free(struct wm_adsp *dsp);
201
202 struct wm_adsp_buffer_region {
203 unsigned int offset;
204 unsigned int cumulative_size;
205 unsigned int mem_type;
206 unsigned int base_addr;
207 };
208
209 struct wm_adsp_buffer_region_def {
210 unsigned int mem_type;
211 unsigned int base_offset;
212 unsigned int size_offset;
213 };
214
215 static const struct wm_adsp_buffer_region_def default_regions[] = {
216 {
217 .mem_type = WMFW_ADSP2_XM,
218 .base_offset = HOST_BUFFER_FIELD(buf1_base),
219 .size_offset = HOST_BUFFER_FIELD(buf1_size),
220 },
221 {
222 .mem_type = WMFW_ADSP2_XM,
223 .base_offset = HOST_BUFFER_FIELD(buf2_base),
224 .size_offset = HOST_BUFFER_FIELD(buf1_buf2_size),
225 },
226 {
227 .mem_type = WMFW_ADSP2_YM,
228 .base_offset = HOST_BUFFER_FIELD(buf3_base),
229 .size_offset = HOST_BUFFER_FIELD(buf_total_size),
230 },
231 };
232
233 struct wm_adsp_fw_caps {
234 u32 id;
235 struct snd_codec_desc desc;
236 int num_regions;
237 const struct wm_adsp_buffer_region_def *region_defs;
238 };
239
240 static const struct wm_adsp_fw_caps ctrl_caps[] = {
241 {
242 .id = SND_AUDIOCODEC_BESPOKE,
243 .desc = {
244 .max_ch = 8,
245 .sample_rates = { 16000 },
246 .num_sample_rates = 1,
247 .formats = SNDRV_PCM_FMTBIT_S16_LE,
248 },
249 .num_regions = ARRAY_SIZE(default_regions),
250 .region_defs = default_regions,
251 },
252 };
253
254 static const struct wm_adsp_fw_caps trace_caps[] = {
255 {
256 .id = SND_AUDIOCODEC_BESPOKE,
257 .desc = {
258 .max_ch = 8,
259 .sample_rates = {
260 4000, 8000, 11025, 12000, 16000, 22050,
261 24000, 32000, 44100, 48000, 64000, 88200,
262 96000, 176400, 192000
263 },
264 .num_sample_rates = 15,
265 .formats = SNDRV_PCM_FMTBIT_S16_LE,
266 },
267 .num_regions = ARRAY_SIZE(default_regions),
268 .region_defs = default_regions,
269 },
270 };
271
272 static const struct {
273 const char *file;
274 int compr_direction;
275 int num_caps;
276 const struct wm_adsp_fw_caps *caps;
277 bool voice_trigger;
278 } wm_adsp_fw[WM_ADSP_NUM_FW] = {
279 [WM_ADSP_FW_MBC_VSS] = { .file = "mbc-vss" },
280 [WM_ADSP_FW_HIFI] = { .file = "hifi" },
281 [WM_ADSP_FW_TX] = { .file = "tx" },
282 [WM_ADSP_FW_TX_SPK] = { .file = "tx-spk" },
283 [WM_ADSP_FW_RX] = { .file = "rx" },
284 [WM_ADSP_FW_RX_ANC] = { .file = "rx-anc" },
285 [WM_ADSP_FW_CTRL] = {
286 .file = "ctrl",
287 .compr_direction = SND_COMPRESS_CAPTURE,
288 .num_caps = ARRAY_SIZE(ctrl_caps),
289 .caps = ctrl_caps,
290 .voice_trigger = true,
291 },
292 [WM_ADSP_FW_ASR] = { .file = "asr" },
293 [WM_ADSP_FW_TRACE] = {
294 .file = "trace",
295 .compr_direction = SND_COMPRESS_CAPTURE,
296 .num_caps = ARRAY_SIZE(trace_caps),
297 .caps = trace_caps,
298 },
299 [WM_ADSP_FW_SPK_PROT] = {
300 .file = "spk-prot",
301 .compr_direction = SND_COMPRESS_CAPTURE,
302 .num_caps = ARRAY_SIZE(trace_caps),
303 .caps = trace_caps,
304 },
305 [WM_ADSP_FW_SPK_CALI] = { .file = "spk-cali" },
306 [WM_ADSP_FW_SPK_DIAG] = { .file = "spk-diag" },
307 [WM_ADSP_FW_MISC] = { .file = "misc" },
308 };
309
310 struct wm_coeff_ctl {
311 const char *name;
312 struct cs_dsp_coeff_ctl *cs_ctl;
313 struct soc_bytes_ext bytes_ext;
314 struct work_struct work;
315 };
316
wm_adsp_fw_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)317 int wm_adsp_fw_get(struct snd_kcontrol *kcontrol,
318 struct snd_ctl_elem_value *ucontrol)
319 {
320 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
321 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
322 struct wm_adsp *dsp = snd_soc_component_get_drvdata(component);
323
324 ucontrol->value.enumerated.item[0] = dsp[e->shift_l].fw;
325
326 return 0;
327 }
328 EXPORT_SYMBOL_GPL(wm_adsp_fw_get);
329
wm_adsp_fw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)330 int wm_adsp_fw_put(struct snd_kcontrol *kcontrol,
331 struct snd_ctl_elem_value *ucontrol)
332 {
333 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
334 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
335 struct wm_adsp *dsp = snd_soc_component_get_drvdata(component);
336 int ret = 1;
337
338 if (ucontrol->value.enumerated.item[0] == dsp[e->shift_l].fw)
339 return 0;
340
341 if (ucontrol->value.enumerated.item[0] >= WM_ADSP_NUM_FW)
342 return -EINVAL;
343
344 mutex_lock(&dsp[e->shift_l].cs_dsp.pwr_lock);
345
346 if (dsp[e->shift_l].cs_dsp.booted || !list_empty(&dsp[e->shift_l].compr_list))
347 ret = -EBUSY;
348 else
349 dsp[e->shift_l].fw = ucontrol->value.enumerated.item[0];
350
351 mutex_unlock(&dsp[e->shift_l].cs_dsp.pwr_lock);
352
353 return ret;
354 }
355 EXPORT_SYMBOL_GPL(wm_adsp_fw_put);
356
357 const struct soc_enum wm_adsp_fw_enum[] = {
358 SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
359 SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
360 SOC_ENUM_SINGLE(0, 2, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
361 SOC_ENUM_SINGLE(0, 3, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
362 SOC_ENUM_SINGLE(0, 4, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
363 SOC_ENUM_SINGLE(0, 5, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
364 SOC_ENUM_SINGLE(0, 6, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
365 };
366 EXPORT_SYMBOL_GPL(wm_adsp_fw_enum);
367
bytes_ext_to_ctl(struct soc_bytes_ext * ext)368 static inline struct wm_coeff_ctl *bytes_ext_to_ctl(struct soc_bytes_ext *ext)
369 {
370 return container_of(ext, struct wm_coeff_ctl, bytes_ext);
371 }
372
wm_coeff_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)373 static int wm_coeff_info(struct snd_kcontrol *kctl,
374 struct snd_ctl_elem_info *uinfo)
375 {
376 struct soc_bytes_ext *bytes_ext =
377 (struct soc_bytes_ext *)kctl->private_value;
378 struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
379 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
380
381 switch (cs_ctl->type) {
382 case WMFW_CTL_TYPE_ACKED:
383 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
384 uinfo->value.integer.min = CS_DSP_ACKED_CTL_MIN_VALUE;
385 uinfo->value.integer.max = CS_DSP_ACKED_CTL_MAX_VALUE;
386 uinfo->value.integer.step = 1;
387 uinfo->count = 1;
388 break;
389 default:
390 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
391 uinfo->count = cs_ctl->len;
392 break;
393 }
394
395 return 0;
396 }
397
wm_coeff_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)398 static int wm_coeff_put(struct snd_kcontrol *kctl,
399 struct snd_ctl_elem_value *ucontrol)
400 {
401 struct soc_bytes_ext *bytes_ext =
402 (struct soc_bytes_ext *)kctl->private_value;
403 struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
404 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
405 char *p = ucontrol->value.bytes.data;
406 int ret = 0;
407
408 mutex_lock(&cs_ctl->dsp->pwr_lock);
409 ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, p, cs_ctl->len);
410 mutex_unlock(&cs_ctl->dsp->pwr_lock);
411
412 return ret;
413 }
414
wm_coeff_tlv_put(struct snd_kcontrol * kctl,const unsigned int __user * bytes,unsigned int size)415 static int wm_coeff_tlv_put(struct snd_kcontrol *kctl,
416 const unsigned int __user *bytes, unsigned int size)
417 {
418 struct soc_bytes_ext *bytes_ext =
419 (struct soc_bytes_ext *)kctl->private_value;
420 struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
421 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
422 void *scratch;
423 int ret = 0;
424
425 scratch = vmalloc(size);
426 if (!scratch)
427 return -ENOMEM;
428
429 if (copy_from_user(scratch, bytes, size)) {
430 ret = -EFAULT;
431 } else {
432 mutex_lock(&cs_ctl->dsp->pwr_lock);
433 ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, scratch, size);
434 mutex_unlock(&cs_ctl->dsp->pwr_lock);
435 }
436 vfree(scratch);
437
438 return ret;
439 }
440
wm_coeff_put_acked(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)441 static int wm_coeff_put_acked(struct snd_kcontrol *kctl,
442 struct snd_ctl_elem_value *ucontrol)
443 {
444 struct soc_bytes_ext *bytes_ext =
445 (struct soc_bytes_ext *)kctl->private_value;
446 struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
447 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
448 unsigned int val = ucontrol->value.integer.value[0];
449 int ret;
450
451 if (val == 0)
452 return 0; /* 0 means no event */
453
454 mutex_lock(&cs_ctl->dsp->pwr_lock);
455
456 if (cs_ctl->enabled)
457 ret = cs_dsp_coeff_write_acked_control(cs_ctl, val);
458 else
459 ret = -EPERM;
460
461 mutex_unlock(&cs_ctl->dsp->pwr_lock);
462
463 if (ret < 0)
464 return ret;
465
466 return 1;
467 }
468
wm_coeff_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)469 static int wm_coeff_get(struct snd_kcontrol *kctl,
470 struct snd_ctl_elem_value *ucontrol)
471 {
472 struct soc_bytes_ext *bytes_ext =
473 (struct soc_bytes_ext *)kctl->private_value;
474 struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
475 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
476 char *p = ucontrol->value.bytes.data;
477 int ret;
478
479 mutex_lock(&cs_ctl->dsp->pwr_lock);
480 ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, p, cs_ctl->len);
481 mutex_unlock(&cs_ctl->dsp->pwr_lock);
482
483 return ret;
484 }
485
wm_coeff_tlv_get(struct snd_kcontrol * kctl,unsigned int __user * bytes,unsigned int size)486 static int wm_coeff_tlv_get(struct snd_kcontrol *kctl,
487 unsigned int __user *bytes, unsigned int size)
488 {
489 struct soc_bytes_ext *bytes_ext =
490 (struct soc_bytes_ext *)kctl->private_value;
491 struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
492 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
493 int ret = 0;
494
495 mutex_lock(&cs_ctl->dsp->pwr_lock);
496
497 ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, cs_ctl->cache, size);
498
499 if (!ret && copy_to_user(bytes, cs_ctl->cache, size))
500 ret = -EFAULT;
501
502 mutex_unlock(&cs_ctl->dsp->pwr_lock);
503
504 return ret;
505 }
506
wm_coeff_get_acked(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)507 static int wm_coeff_get_acked(struct snd_kcontrol *kcontrol,
508 struct snd_ctl_elem_value *ucontrol)
509 {
510 /*
511 * Although it's not useful to read an acked control, we must satisfy
512 * user-side assumptions that all controls are readable and that a
513 * write of the same value should be filtered out (it's valid to send
514 * the same event number again to the firmware). We therefore return 0,
515 * meaning "no event" so valid event numbers will always be a change
516 */
517 ucontrol->value.integer.value[0] = 0;
518
519 return 0;
520 }
521
wmfw_convert_flags(unsigned int in,unsigned int len)522 static unsigned int wmfw_convert_flags(unsigned int in, unsigned int len)
523 {
524 unsigned int out, rd, wr, vol;
525
526 if (len > ADSP_MAX_STD_CTRL_SIZE) {
527 rd = SNDRV_CTL_ELEM_ACCESS_TLV_READ;
528 wr = SNDRV_CTL_ELEM_ACCESS_TLV_WRITE;
529 vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;
530
531 out = SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
532 } else {
533 rd = SNDRV_CTL_ELEM_ACCESS_READ;
534 wr = SNDRV_CTL_ELEM_ACCESS_WRITE;
535 vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;
536
537 out = 0;
538 }
539
540 if (in) {
541 out |= rd;
542 if (in & WMFW_CTL_FLAG_WRITEABLE)
543 out |= wr;
544 if (in & WMFW_CTL_FLAG_VOLATILE)
545 out |= vol;
546 } else {
547 out |= rd | wr | vol;
548 }
549
550 return out;
551 }
552
wm_adsp_ctl_work(struct work_struct * work)553 static void wm_adsp_ctl_work(struct work_struct *work)
554 {
555 struct wm_coeff_ctl *ctl = container_of(work,
556 struct wm_coeff_ctl,
557 work);
558 struct cs_dsp_coeff_ctl *cs_ctl = ctl->cs_ctl;
559 struct wm_adsp *dsp = container_of(cs_ctl->dsp,
560 struct wm_adsp,
561 cs_dsp);
562 struct snd_kcontrol_new *kcontrol;
563
564 kcontrol = kzalloc(sizeof(*kcontrol), GFP_KERNEL);
565 if (!kcontrol)
566 return;
567
568 kcontrol->name = ctl->name;
569 kcontrol->info = wm_coeff_info;
570 kcontrol->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
571 kcontrol->tlv.c = snd_soc_bytes_tlv_callback;
572 kcontrol->private_value = (unsigned long)&ctl->bytes_ext;
573 kcontrol->access = wmfw_convert_flags(cs_ctl->flags, cs_ctl->len);
574
575 switch (cs_ctl->type) {
576 case WMFW_CTL_TYPE_ACKED:
577 kcontrol->get = wm_coeff_get_acked;
578 kcontrol->put = wm_coeff_put_acked;
579 break;
580 default:
581 if (kcontrol->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
582 ctl->bytes_ext.max = cs_ctl->len;
583 ctl->bytes_ext.get = wm_coeff_tlv_get;
584 ctl->bytes_ext.put = wm_coeff_tlv_put;
585 } else {
586 kcontrol->get = wm_coeff_get;
587 kcontrol->put = wm_coeff_put;
588 }
589 break;
590 }
591
592 snd_soc_add_component_controls(dsp->component, kcontrol, 1);
593
594 kfree(kcontrol);
595 }
596
wm_adsp_control_add(struct cs_dsp_coeff_ctl * cs_ctl)597 static int wm_adsp_control_add(struct cs_dsp_coeff_ctl *cs_ctl)
598 {
599 struct wm_adsp *dsp = container_of(cs_ctl->dsp, struct wm_adsp, cs_dsp);
600 struct cs_dsp *cs_dsp = &dsp->cs_dsp;
601 struct wm_coeff_ctl *ctl;
602 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
603 const char *region_name;
604 int ret;
605
606 if (cs_ctl->flags & WMFW_CTL_FLAG_SYS)
607 return 0;
608
609 region_name = cs_dsp_mem_region_name(cs_ctl->alg_region.type);
610 if (!region_name) {
611 adsp_err(dsp, "Unknown region type: %d\n", cs_ctl->alg_region.type);
612 return -EINVAL;
613 }
614
615 switch (cs_dsp->fw_ver) {
616 case 0:
617 case 1:
618 ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
619 "%s %s %x", cs_dsp->name, region_name,
620 cs_ctl->alg_region.alg);
621 break;
622 case 2:
623 ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
624 "%s%c %.12s %x", cs_dsp->name, *region_name,
625 wm_adsp_fw_text[dsp->fw], cs_ctl->alg_region.alg);
626 break;
627 default:
628 ret = scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
629 "%s %.12s %x", cs_dsp->name,
630 wm_adsp_fw_text[dsp->fw], cs_ctl->alg_region.alg);
631 break;
632 }
633
634 if (cs_ctl->subname) {
635 int avail = SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret - 2;
636 int skip = 0;
637
638 if (dsp->component->name_prefix)
639 avail -= strlen(dsp->component->name_prefix) + 1;
640
641 /* Truncate the subname from the start if it is too long */
642 if (cs_ctl->subname_len > avail)
643 skip = cs_ctl->subname_len - avail;
644
645 snprintf(name + ret, SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret,
646 " %.*s", cs_ctl->subname_len - skip, cs_ctl->subname + skip);
647 }
648
649 ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
650 if (!ctl)
651 return -ENOMEM;
652 ctl->cs_ctl = cs_ctl;
653
654 ctl->name = kmemdup(name, strlen(name) + 1, GFP_KERNEL);
655 if (!ctl->name) {
656 ret = -ENOMEM;
657 goto err_ctl;
658 }
659
660 cs_ctl->priv = ctl;
661
662 INIT_WORK(&ctl->work, wm_adsp_ctl_work);
663 schedule_work(&ctl->work);
664
665 return 0;
666
667 err_ctl:
668 kfree(ctl);
669
670 return ret;
671 }
672
wm_adsp_control_remove(struct cs_dsp_coeff_ctl * cs_ctl)673 static void wm_adsp_control_remove(struct cs_dsp_coeff_ctl *cs_ctl)
674 {
675 struct wm_coeff_ctl *ctl = cs_ctl->priv;
676
677 cancel_work_sync(&ctl->work);
678
679 kfree(ctl->name);
680 kfree(ctl);
681 }
682
wm_adsp_write_ctl(struct wm_adsp * dsp,const char * name,int type,unsigned int alg,void * buf,size_t len)683 int wm_adsp_write_ctl(struct wm_adsp *dsp, const char *name, int type,
684 unsigned int alg, void *buf, size_t len)
685 {
686 struct cs_dsp_coeff_ctl *cs_ctl = cs_dsp_get_ctl(&dsp->cs_dsp, name, type, alg);
687 struct wm_coeff_ctl *ctl;
688 int ret;
689
690 mutex_lock(&dsp->cs_dsp.pwr_lock);
691 ret = cs_dsp_coeff_write_ctrl(cs_ctl, 0, buf, len);
692 mutex_unlock(&dsp->cs_dsp.pwr_lock);
693
694 if (ret < 0)
695 return ret;
696
697 if (ret == 0 || (cs_ctl->flags & WMFW_CTL_FLAG_SYS))
698 return 0;
699
700 ctl = cs_ctl->priv;
701
702 return snd_soc_component_notify_control(dsp->component, ctl->name);
703 }
704 EXPORT_SYMBOL_GPL(wm_adsp_write_ctl);
705
wm_adsp_read_ctl(struct wm_adsp * dsp,const char * name,int type,unsigned int alg,void * buf,size_t len)706 int wm_adsp_read_ctl(struct wm_adsp *dsp, const char *name, int type,
707 unsigned int alg, void *buf, size_t len)
708 {
709 int ret;
710
711 mutex_lock(&dsp->cs_dsp.pwr_lock);
712 ret = cs_dsp_coeff_read_ctrl(cs_dsp_get_ctl(&dsp->cs_dsp, name, type, alg),
713 0, buf, len);
714 mutex_unlock(&dsp->cs_dsp.pwr_lock);
715
716 return ret;
717 }
718 EXPORT_SYMBOL_GPL(wm_adsp_read_ctl);
719
wm_adsp_release_firmware_files(struct wm_adsp * dsp,const struct firmware * wmfw_firmware,char * wmfw_filename,const struct firmware * coeff_firmware,char * coeff_filename)720 static void wm_adsp_release_firmware_files(struct wm_adsp *dsp,
721 const struct firmware *wmfw_firmware,
722 char *wmfw_filename,
723 const struct firmware *coeff_firmware,
724 char *coeff_filename)
725 {
726 if (wmfw_firmware)
727 release_firmware(wmfw_firmware);
728 kfree(wmfw_filename);
729
730 if (coeff_firmware)
731 release_firmware(coeff_firmware);
732 kfree(coeff_filename);
733 }
734
wm_adsp_request_firmware_file(struct wm_adsp * dsp,const struct firmware ** firmware,char ** filename,const char * dir,const char * system_name,const char * asoc_component_prefix,const char * filetype)735 static int wm_adsp_request_firmware_file(struct wm_adsp *dsp,
736 const struct firmware **firmware, char **filename,
737 const char *dir, const char *system_name,
738 const char *asoc_component_prefix,
739 const char *filetype)
740 {
741 struct cs_dsp *cs_dsp = &dsp->cs_dsp;
742 const char *fwf;
743 char *s, c;
744 int ret = 0;
745
746 if (dsp->fwf_name)
747 fwf = dsp->fwf_name;
748 else
749 fwf = dsp->cs_dsp.name;
750
751 if (system_name && asoc_component_prefix)
752 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-%s.%s", dir, dsp->part,
753 fwf, wm_adsp_fw[dsp->fw].file, system_name,
754 asoc_component_prefix, filetype);
755 else if (system_name)
756 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s.%s", dir, dsp->part,
757 fwf, wm_adsp_fw[dsp->fw].file, system_name,
758 filetype);
759 else
760 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s.%s", dir, dsp->part, fwf,
761 wm_adsp_fw[dsp->fw].file, filetype);
762
763 if (*filename == NULL)
764 return -ENOMEM;
765
766 /*
767 * Make sure that filename is lower-case and any non alpha-numeric
768 * characters except full stop and forward slash are replaced with
769 * hyphens.
770 */
771 s = *filename;
772 while (*s) {
773 c = *s;
774 if (isalnum(c))
775 *s = tolower(c);
776 else if ((c != '.') && (c != '/'))
777 *s = '-';
778 s++;
779 }
780
781 ret = firmware_request_nowarn(firmware, *filename, cs_dsp->dev);
782 if (ret != 0) {
783 adsp_dbg(dsp, "Failed to request '%s'\n", *filename);
784 kfree(*filename);
785 *filename = NULL;
786 } else {
787 adsp_dbg(dsp, "Found '%s'\n", *filename);
788 }
789
790 return ret;
791 }
792
793 static const char *cirrus_dir = "cirrus/";
wm_adsp_request_firmware_files(struct wm_adsp * dsp,const struct firmware ** wmfw_firmware,char ** wmfw_filename,const struct firmware ** coeff_firmware,char ** coeff_filename)794 static int wm_adsp_request_firmware_files(struct wm_adsp *dsp,
795 const struct firmware **wmfw_firmware,
796 char **wmfw_filename,
797 const struct firmware **coeff_firmware,
798 char **coeff_filename)
799 {
800 const char *system_name = dsp->system_name;
801 const char *asoc_component_prefix = dsp->component->name_prefix;
802 int ret = 0;
803
804 if (system_name && asoc_component_prefix) {
805 if (!wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
806 cirrus_dir, system_name,
807 asoc_component_prefix, "wmfw")) {
808 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
809 cirrus_dir, system_name,
810 asoc_component_prefix, "bin");
811 return 0;
812 }
813 }
814
815 if (system_name) {
816 if (!wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
817 cirrus_dir, system_name,
818 NULL, "wmfw")) {
819 if (asoc_component_prefix)
820 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
821 cirrus_dir, system_name,
822 asoc_component_prefix, "bin");
823
824 if (!*coeff_firmware)
825 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
826 cirrus_dir, system_name,
827 NULL, "bin");
828 return 0;
829 }
830 }
831
832 /* Check system-specific bin without wmfw before falling back to generic */
833 if (dsp->wmfw_optional && system_name) {
834 if (asoc_component_prefix)
835 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
836 cirrus_dir, system_name,
837 asoc_component_prefix, "bin");
838
839 if (!*coeff_firmware)
840 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
841 cirrus_dir, system_name,
842 NULL, "bin");
843
844 if (*coeff_firmware)
845 return 0;
846 }
847
848 /* Check legacy location */
849 if (!wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
850 "", NULL, NULL, "wmfw")) {
851 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
852 "", NULL, NULL, "bin");
853 return 0;
854 }
855
856 /* Fall back to generic wmfw and optional matching bin */
857 ret = wm_adsp_request_firmware_file(dsp, wmfw_firmware, wmfw_filename,
858 cirrus_dir, NULL, NULL, "wmfw");
859 if (!ret || dsp->wmfw_optional) {
860 wm_adsp_request_firmware_file(dsp, coeff_firmware, coeff_filename,
861 cirrus_dir, NULL, NULL, "bin");
862 return 0;
863 }
864
865 adsp_err(dsp, "Failed to request firmware <%s>%s-%s-%s<-%s<%s>>.wmfw\n",
866 cirrus_dir, dsp->part,
867 dsp->fwf_name ? dsp->fwf_name : dsp->cs_dsp.name,
868 wm_adsp_fw[dsp->fw].file, system_name, asoc_component_prefix);
869
870 return -ENOENT;
871 }
872
wm_adsp_common_init(struct wm_adsp * dsp)873 static int wm_adsp_common_init(struct wm_adsp *dsp)
874 {
875 INIT_LIST_HEAD(&dsp->compr_list);
876 INIT_LIST_HEAD(&dsp->buffer_list);
877
878 return 0;
879 }
880
wm_adsp1_init(struct wm_adsp * dsp)881 int wm_adsp1_init(struct wm_adsp *dsp)
882 {
883 int ret;
884
885 dsp->cs_dsp.client_ops = &wm_adsp1_client_ops;
886
887 ret = cs_dsp_adsp1_init(&dsp->cs_dsp);
888 if (ret)
889 return ret;
890
891 return wm_adsp_common_init(dsp);
892 }
893 EXPORT_SYMBOL_GPL(wm_adsp1_init);
894
wm_adsp1_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)895 int wm_adsp1_event(struct snd_soc_dapm_widget *w,
896 struct snd_kcontrol *kcontrol,
897 int event)
898 {
899 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
900 struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
901 struct wm_adsp *dsp = &dsps[w->shift];
902 int ret = 0;
903 char *wmfw_filename = NULL;
904 const struct firmware *wmfw_firmware = NULL;
905 char *coeff_filename = NULL;
906 const struct firmware *coeff_firmware = NULL;
907
908 dsp->component = component;
909
910 switch (event) {
911 case SND_SOC_DAPM_POST_PMU:
912 ret = wm_adsp_request_firmware_files(dsp,
913 &wmfw_firmware, &wmfw_filename,
914 &coeff_firmware, &coeff_filename);
915 if (ret)
916 break;
917
918 ret = cs_dsp_adsp1_power_up(&dsp->cs_dsp,
919 wmfw_firmware, wmfw_filename,
920 coeff_firmware, coeff_filename,
921 wm_adsp_fw_text[dsp->fw]);
922
923 wm_adsp_release_firmware_files(dsp,
924 wmfw_firmware, wmfw_filename,
925 coeff_firmware, coeff_filename);
926 break;
927 case SND_SOC_DAPM_PRE_PMD:
928 cs_dsp_adsp1_power_down(&dsp->cs_dsp);
929 break;
930 default:
931 break;
932 }
933
934 return ret;
935 }
936 EXPORT_SYMBOL_GPL(wm_adsp1_event);
937
wm_adsp2_set_dspclk(struct snd_soc_dapm_widget * w,unsigned int freq)938 int wm_adsp2_set_dspclk(struct snd_soc_dapm_widget *w, unsigned int freq)
939 {
940 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
941 struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
942 struct wm_adsp *dsp = &dsps[w->shift];
943
944 return cs_dsp_set_dspclk(&dsp->cs_dsp, freq);
945 }
946 EXPORT_SYMBOL_GPL(wm_adsp2_set_dspclk);
947
wm_adsp2_preloader_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)948 int wm_adsp2_preloader_get(struct snd_kcontrol *kcontrol,
949 struct snd_ctl_elem_value *ucontrol)
950 {
951 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
952 struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
953 struct soc_mixer_control *mc =
954 (struct soc_mixer_control *)kcontrol->private_value;
955 struct wm_adsp *dsp = &dsps[mc->shift - 1];
956
957 ucontrol->value.integer.value[0] = dsp->preloaded;
958
959 return 0;
960 }
961 EXPORT_SYMBOL_GPL(wm_adsp2_preloader_get);
962
wm_adsp2_preloader_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)963 int wm_adsp2_preloader_put(struct snd_kcontrol *kcontrol,
964 struct snd_ctl_elem_value *ucontrol)
965 {
966 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
967 struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
968 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
969 struct soc_mixer_control *mc =
970 (struct soc_mixer_control *)kcontrol->private_value;
971 struct wm_adsp *dsp = &dsps[mc->shift - 1];
972 char preload[32];
973
974 if (dsp->preloaded == ucontrol->value.integer.value[0])
975 return 0;
976
977 snprintf(preload, ARRAY_SIZE(preload), "%s Preload", dsp->cs_dsp.name);
978
979 if (ucontrol->value.integer.value[0] || dsp->toggle_preload)
980 snd_soc_component_force_enable_pin(component, preload);
981 else
982 snd_soc_component_disable_pin(component, preload);
983
984 snd_soc_dapm_sync(dapm);
985
986 flush_work(&dsp->boot_work);
987
988 dsp->preloaded = ucontrol->value.integer.value[0];
989
990 if (dsp->toggle_preload) {
991 snd_soc_component_disable_pin(component, preload);
992 snd_soc_dapm_sync(dapm);
993 }
994
995 return 1;
996 }
997 EXPORT_SYMBOL_GPL(wm_adsp2_preloader_put);
998
wm_adsp_power_up(struct wm_adsp * dsp,bool load_firmware)999 int wm_adsp_power_up(struct wm_adsp *dsp, bool load_firmware)
1000 {
1001 int ret = 0;
1002 char *wmfw_filename = NULL;
1003 const struct firmware *wmfw_firmware = NULL;
1004 char *coeff_filename = NULL;
1005 const struct firmware *coeff_firmware = NULL;
1006
1007 if (load_firmware) {
1008 ret = wm_adsp_request_firmware_files(dsp,
1009 &wmfw_firmware, &wmfw_filename,
1010 &coeff_firmware, &coeff_filename);
1011 if (ret)
1012 return ret;
1013 }
1014
1015 ret = cs_dsp_power_up(&dsp->cs_dsp,
1016 wmfw_firmware, wmfw_filename,
1017 coeff_firmware, coeff_filename,
1018 wm_adsp_fw_text[dsp->fw]);
1019
1020 wm_adsp_release_firmware_files(dsp,
1021 wmfw_firmware, wmfw_filename,
1022 coeff_firmware, coeff_filename);
1023
1024 return ret;
1025 }
1026 EXPORT_SYMBOL_GPL(wm_adsp_power_up);
1027
wm_adsp_power_down(struct wm_adsp * dsp)1028 void wm_adsp_power_down(struct wm_adsp *dsp)
1029 {
1030 cs_dsp_power_down(&dsp->cs_dsp);
1031 }
1032 EXPORT_SYMBOL_GPL(wm_adsp_power_down);
1033
wm_adsp_boot_work(struct work_struct * work)1034 static void wm_adsp_boot_work(struct work_struct *work)
1035 {
1036 struct wm_adsp *dsp = container_of(work,
1037 struct wm_adsp,
1038 boot_work);
1039
1040 wm_adsp_power_up(dsp, true);
1041 }
1042
wm_adsp_early_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1043 int wm_adsp_early_event(struct snd_soc_dapm_widget *w,
1044 struct snd_kcontrol *kcontrol, int event)
1045 {
1046 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1047 struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
1048 struct wm_adsp *dsp = &dsps[w->shift];
1049
1050 switch (event) {
1051 case SND_SOC_DAPM_PRE_PMU:
1052 queue_work(system_unbound_wq, &dsp->boot_work);
1053 break;
1054 case SND_SOC_DAPM_PRE_PMD:
1055 wm_adsp_power_down(dsp);
1056 break;
1057 default:
1058 break;
1059 }
1060
1061 return 0;
1062 }
1063 EXPORT_SYMBOL_GPL(wm_adsp_early_event);
1064
wm_adsp_pre_run(struct cs_dsp * cs_dsp)1065 static int wm_adsp_pre_run(struct cs_dsp *cs_dsp)
1066 {
1067 struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
1068
1069 if (!dsp->pre_run)
1070 return 0;
1071
1072 return (*dsp->pre_run)(dsp);
1073 }
1074
wm_adsp_event_post_run(struct cs_dsp * cs_dsp)1075 static int wm_adsp_event_post_run(struct cs_dsp *cs_dsp)
1076 {
1077 struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
1078
1079 if (wm_adsp_fw[dsp->fw].num_caps != 0)
1080 return wm_adsp_buffer_init(dsp);
1081
1082 return 0;
1083 }
1084
wm_adsp_event_post_stop(struct cs_dsp * cs_dsp)1085 static void wm_adsp_event_post_stop(struct cs_dsp *cs_dsp)
1086 {
1087 struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
1088
1089 if (wm_adsp_fw[dsp->fw].num_caps != 0)
1090 wm_adsp_buffer_free(dsp);
1091
1092 dsp->fatal_error = false;
1093 }
1094
wm_adsp_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1095 int wm_adsp_event(struct snd_soc_dapm_widget *w,
1096 struct snd_kcontrol *kcontrol, int event)
1097 {
1098 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1099 struct wm_adsp *dsps = snd_soc_component_get_drvdata(component);
1100 struct wm_adsp *dsp = &dsps[w->shift];
1101 int ret = 0;
1102
1103 switch (event) {
1104 case SND_SOC_DAPM_POST_PMU:
1105 flush_work(&dsp->boot_work);
1106 ret = cs_dsp_run(&dsp->cs_dsp);
1107 break;
1108 case SND_SOC_DAPM_PRE_PMD:
1109 cs_dsp_stop(&dsp->cs_dsp);
1110 break;
1111 default:
1112 break;
1113 }
1114
1115 return ret;
1116 }
1117 EXPORT_SYMBOL_GPL(wm_adsp_event);
1118
wm_adsp2_component_probe(struct wm_adsp * dsp,struct snd_soc_component * component)1119 int wm_adsp2_component_probe(struct wm_adsp *dsp, struct snd_soc_component *component)
1120 {
1121 char preload[32];
1122
1123 if (!dsp->cs_dsp.no_core_startstop) {
1124 snprintf(preload, ARRAY_SIZE(preload), "%s Preload", dsp->cs_dsp.name);
1125 snd_soc_component_disable_pin(component, preload);
1126 }
1127
1128 cs_dsp_init_debugfs(&dsp->cs_dsp, component->debugfs_root);
1129
1130 dsp->component = component;
1131
1132 return 0;
1133 }
1134 EXPORT_SYMBOL_GPL(wm_adsp2_component_probe);
1135
wm_adsp2_component_remove(struct wm_adsp * dsp,struct snd_soc_component * component)1136 int wm_adsp2_component_remove(struct wm_adsp *dsp, struct snd_soc_component *component)
1137 {
1138 cs_dsp_cleanup_debugfs(&dsp->cs_dsp);
1139
1140 return 0;
1141 }
1142 EXPORT_SYMBOL_GPL(wm_adsp2_component_remove);
1143
wm_adsp2_init(struct wm_adsp * dsp)1144 int wm_adsp2_init(struct wm_adsp *dsp)
1145 {
1146 int ret;
1147
1148 INIT_WORK(&dsp->boot_work, wm_adsp_boot_work);
1149
1150 dsp->sys_config_size = sizeof(struct wm_adsp_system_config_xm_hdr);
1151 dsp->cs_dsp.client_ops = &wm_adsp2_client_ops;
1152
1153 ret = cs_dsp_adsp2_init(&dsp->cs_dsp);
1154 if (ret)
1155 return ret;
1156
1157 return wm_adsp_common_init(dsp);
1158 }
1159 EXPORT_SYMBOL_GPL(wm_adsp2_init);
1160
wm_halo_init(struct wm_adsp * dsp)1161 int wm_halo_init(struct wm_adsp *dsp)
1162 {
1163 int ret;
1164
1165 INIT_WORK(&dsp->boot_work, wm_adsp_boot_work);
1166
1167 dsp->sys_config_size = sizeof(struct wm_halo_system_config_xm_hdr);
1168 dsp->cs_dsp.client_ops = &wm_adsp2_client_ops;
1169
1170 ret = cs_dsp_halo_init(&dsp->cs_dsp);
1171 if (ret)
1172 return ret;
1173
1174 return wm_adsp_common_init(dsp);
1175 }
1176 EXPORT_SYMBOL_GPL(wm_halo_init);
1177
wm_adsp2_remove(struct wm_adsp * dsp)1178 void wm_adsp2_remove(struct wm_adsp *dsp)
1179 {
1180 cs_dsp_remove(&dsp->cs_dsp);
1181 }
1182 EXPORT_SYMBOL_GPL(wm_adsp2_remove);
1183
wm_adsp_compr_attached(struct wm_adsp_compr * compr)1184 static inline int wm_adsp_compr_attached(struct wm_adsp_compr *compr)
1185 {
1186 return compr->buf != NULL;
1187 }
1188
wm_adsp_compr_attach(struct wm_adsp_compr * compr)1189 static int wm_adsp_compr_attach(struct wm_adsp_compr *compr)
1190 {
1191 struct wm_adsp_compr_buf *buf = NULL, *tmp;
1192
1193 if (compr->dsp->fatal_error)
1194 return -EINVAL;
1195
1196 list_for_each_entry(tmp, &compr->dsp->buffer_list, list) {
1197 if (!tmp->name || !strcmp(compr->name, tmp->name)) {
1198 buf = tmp;
1199 break;
1200 }
1201 }
1202
1203 if (!buf)
1204 return -EINVAL;
1205
1206 compr->buf = buf;
1207 buf->compr = compr;
1208
1209 return 0;
1210 }
1211
wm_adsp_compr_detach(struct wm_adsp_compr * compr)1212 static void wm_adsp_compr_detach(struct wm_adsp_compr *compr)
1213 {
1214 if (!compr)
1215 return;
1216
1217 /* Wake the poll so it can see buffer is no longer attached */
1218 if (compr->stream)
1219 snd_compr_fragment_elapsed(compr->stream);
1220
1221 if (wm_adsp_compr_attached(compr)) {
1222 compr->buf->compr = NULL;
1223 compr->buf = NULL;
1224 }
1225 }
1226
wm_adsp_compr_open(struct wm_adsp * dsp,struct snd_compr_stream * stream)1227 int wm_adsp_compr_open(struct wm_adsp *dsp, struct snd_compr_stream *stream)
1228 {
1229 struct wm_adsp_compr *compr, *tmp;
1230 struct snd_soc_pcm_runtime *rtd = stream->private_data;
1231 int ret = 0;
1232
1233 mutex_lock(&dsp->cs_dsp.pwr_lock);
1234
1235 if (wm_adsp_fw[dsp->fw].num_caps == 0) {
1236 adsp_err(dsp, "%s: Firmware does not support compressed API\n",
1237 snd_soc_rtd_to_codec(rtd, 0)->name);
1238 ret = -ENXIO;
1239 goto out;
1240 }
1241
1242 if (wm_adsp_fw[dsp->fw].compr_direction != stream->direction) {
1243 adsp_err(dsp, "%s: Firmware does not support stream direction\n",
1244 snd_soc_rtd_to_codec(rtd, 0)->name);
1245 ret = -EINVAL;
1246 goto out;
1247 }
1248
1249 list_for_each_entry(tmp, &dsp->compr_list, list) {
1250 if (!strcmp(tmp->name, snd_soc_rtd_to_codec(rtd, 0)->name)) {
1251 adsp_err(dsp, "%s: Only a single stream supported per dai\n",
1252 snd_soc_rtd_to_codec(rtd, 0)->name);
1253 ret = -EBUSY;
1254 goto out;
1255 }
1256 }
1257
1258 compr = kzalloc(sizeof(*compr), GFP_KERNEL);
1259 if (!compr) {
1260 ret = -ENOMEM;
1261 goto out;
1262 }
1263
1264 compr->dsp = dsp;
1265 compr->stream = stream;
1266 compr->name = snd_soc_rtd_to_codec(rtd, 0)->name;
1267
1268 list_add_tail(&compr->list, &dsp->compr_list);
1269
1270 stream->runtime->private_data = compr;
1271
1272 out:
1273 mutex_unlock(&dsp->cs_dsp.pwr_lock);
1274
1275 return ret;
1276 }
1277 EXPORT_SYMBOL_GPL(wm_adsp_compr_open);
1278
wm_adsp_compr_free(struct snd_soc_component * component,struct snd_compr_stream * stream)1279 int wm_adsp_compr_free(struct snd_soc_component *component,
1280 struct snd_compr_stream *stream)
1281 {
1282 struct wm_adsp_compr *compr = stream->runtime->private_data;
1283 struct wm_adsp *dsp = compr->dsp;
1284
1285 mutex_lock(&dsp->cs_dsp.pwr_lock);
1286
1287 wm_adsp_compr_detach(compr);
1288 list_del(&compr->list);
1289
1290 kfree(compr->raw_buf);
1291 kfree(compr);
1292
1293 mutex_unlock(&dsp->cs_dsp.pwr_lock);
1294
1295 return 0;
1296 }
1297 EXPORT_SYMBOL_GPL(wm_adsp_compr_free);
1298
wm_adsp_compr_check_params(struct snd_compr_stream * stream,struct snd_compr_params * params)1299 static int wm_adsp_compr_check_params(struct snd_compr_stream *stream,
1300 struct snd_compr_params *params)
1301 {
1302 struct wm_adsp_compr *compr = stream->runtime->private_data;
1303 struct wm_adsp *dsp = compr->dsp;
1304 const struct wm_adsp_fw_caps *caps;
1305 const struct snd_codec_desc *desc;
1306 int i, j;
1307
1308 if (params->buffer.fragment_size < WM_ADSP_MIN_FRAGMENT_SIZE ||
1309 params->buffer.fragment_size > WM_ADSP_MAX_FRAGMENT_SIZE ||
1310 params->buffer.fragments < WM_ADSP_MIN_FRAGMENTS ||
1311 params->buffer.fragments > WM_ADSP_MAX_FRAGMENTS ||
1312 params->buffer.fragment_size % CS_DSP_DATA_WORD_SIZE) {
1313 compr_err(compr, "Invalid buffer fragsize=%d fragments=%d\n",
1314 params->buffer.fragment_size,
1315 params->buffer.fragments);
1316
1317 return -EINVAL;
1318 }
1319
1320 for (i = 0; i < wm_adsp_fw[dsp->fw].num_caps; i++) {
1321 caps = &wm_adsp_fw[dsp->fw].caps[i];
1322 desc = &caps->desc;
1323
1324 if (caps->id != params->codec.id)
1325 continue;
1326
1327 if (stream->direction == SND_COMPRESS_PLAYBACK) {
1328 if (desc->max_ch < params->codec.ch_out)
1329 continue;
1330 } else {
1331 if (desc->max_ch < params->codec.ch_in)
1332 continue;
1333 }
1334
1335 if (!(desc->formats & (1 << params->codec.format)))
1336 continue;
1337
1338 for (j = 0; j < desc->num_sample_rates; ++j)
1339 if (desc->sample_rates[j] == params->codec.sample_rate)
1340 return 0;
1341 }
1342
1343 compr_err(compr, "Invalid params id=%u ch=%u,%u rate=%u fmt=%u\n",
1344 params->codec.id, params->codec.ch_in, params->codec.ch_out,
1345 params->codec.sample_rate, params->codec.format);
1346 return -EINVAL;
1347 }
1348
wm_adsp_compr_frag_words(struct wm_adsp_compr * compr)1349 static inline unsigned int wm_adsp_compr_frag_words(struct wm_adsp_compr *compr)
1350 {
1351 return compr->size.fragment_size / CS_DSP_DATA_WORD_SIZE;
1352 }
1353
wm_adsp_compr_set_params(struct snd_soc_component * component,struct snd_compr_stream * stream,struct snd_compr_params * params)1354 int wm_adsp_compr_set_params(struct snd_soc_component *component,
1355 struct snd_compr_stream *stream,
1356 struct snd_compr_params *params)
1357 {
1358 struct wm_adsp_compr *compr = stream->runtime->private_data;
1359 unsigned int size;
1360 int ret;
1361
1362 ret = wm_adsp_compr_check_params(stream, params);
1363 if (ret)
1364 return ret;
1365
1366 compr->size = params->buffer;
1367
1368 compr_dbg(compr, "fragment_size=%d fragments=%d\n",
1369 compr->size.fragment_size, compr->size.fragments);
1370
1371 size = wm_adsp_compr_frag_words(compr) * sizeof(*compr->raw_buf);
1372 compr->raw_buf = kmalloc(size, GFP_DMA | GFP_KERNEL);
1373 if (!compr->raw_buf)
1374 return -ENOMEM;
1375
1376 compr->sample_rate = params->codec.sample_rate;
1377
1378 return 0;
1379 }
1380 EXPORT_SYMBOL_GPL(wm_adsp_compr_set_params);
1381
wm_adsp_compr_get_caps(struct snd_soc_component * component,struct snd_compr_stream * stream,struct snd_compr_caps * caps)1382 int wm_adsp_compr_get_caps(struct snd_soc_component *component,
1383 struct snd_compr_stream *stream,
1384 struct snd_compr_caps *caps)
1385 {
1386 struct wm_adsp_compr *compr = stream->runtime->private_data;
1387 int fw = compr->dsp->fw;
1388 int i;
1389
1390 if (wm_adsp_fw[fw].caps) {
1391 for (i = 0; i < wm_adsp_fw[fw].num_caps; i++)
1392 caps->codecs[i] = wm_adsp_fw[fw].caps[i].id;
1393
1394 caps->num_codecs = i;
1395 caps->direction = wm_adsp_fw[fw].compr_direction;
1396
1397 caps->min_fragment_size = WM_ADSP_MIN_FRAGMENT_SIZE;
1398 caps->max_fragment_size = WM_ADSP_MAX_FRAGMENT_SIZE;
1399 caps->min_fragments = WM_ADSP_MIN_FRAGMENTS;
1400 caps->max_fragments = WM_ADSP_MAX_FRAGMENTS;
1401 }
1402
1403 return 0;
1404 }
1405 EXPORT_SYMBOL_GPL(wm_adsp_compr_get_caps);
1406
wm_adsp_buffer_read(struct wm_adsp_compr_buf * buf,unsigned int field_offset,u32 * data)1407 static inline int wm_adsp_buffer_read(struct wm_adsp_compr_buf *buf,
1408 unsigned int field_offset, u32 *data)
1409 {
1410 return cs_dsp_read_data_word(&buf->dsp->cs_dsp, buf->host_buf_mem_type,
1411 buf->host_buf_ptr + field_offset, data);
1412 }
1413
wm_adsp_buffer_write(struct wm_adsp_compr_buf * buf,unsigned int field_offset,u32 data)1414 static inline int wm_adsp_buffer_write(struct wm_adsp_compr_buf *buf,
1415 unsigned int field_offset, u32 data)
1416 {
1417 return cs_dsp_write_data_word(&buf->dsp->cs_dsp, buf->host_buf_mem_type,
1418 buf->host_buf_ptr + field_offset,
1419 data);
1420 }
1421
wm_adsp_buffer_populate(struct wm_adsp_compr_buf * buf)1422 static int wm_adsp_buffer_populate(struct wm_adsp_compr_buf *buf)
1423 {
1424 const struct wm_adsp_fw_caps *caps = wm_adsp_fw[buf->dsp->fw].caps;
1425 struct wm_adsp_buffer_region *region;
1426 u32 offset = 0;
1427 int i, ret;
1428
1429 buf->regions = kcalloc(caps->num_regions, sizeof(*buf->regions),
1430 GFP_KERNEL);
1431 if (!buf->regions)
1432 return -ENOMEM;
1433
1434 for (i = 0; i < caps->num_regions; ++i) {
1435 region = &buf->regions[i];
1436
1437 region->offset = offset;
1438 region->mem_type = caps->region_defs[i].mem_type;
1439
1440 ret = wm_adsp_buffer_read(buf, caps->region_defs[i].base_offset,
1441 ®ion->base_addr);
1442 if (ret < 0)
1443 goto err;
1444
1445 ret = wm_adsp_buffer_read(buf, caps->region_defs[i].size_offset,
1446 &offset);
1447 if (ret < 0)
1448 goto err;
1449
1450 region->cumulative_size = offset;
1451
1452 compr_dbg(buf,
1453 "region=%d type=%d base=%08x off=%08x size=%08x\n",
1454 i, region->mem_type, region->base_addr,
1455 region->offset, region->cumulative_size);
1456 }
1457
1458 return 0;
1459
1460 err:
1461 kfree(buf->regions);
1462 return ret;
1463 }
1464
wm_adsp_buffer_clear(struct wm_adsp_compr_buf * buf)1465 static void wm_adsp_buffer_clear(struct wm_adsp_compr_buf *buf)
1466 {
1467 buf->irq_count = 0xFFFFFFFF;
1468 buf->read_index = -1;
1469 buf->avail = 0;
1470 }
1471
wm_adsp_buffer_alloc(struct wm_adsp * dsp)1472 static struct wm_adsp_compr_buf *wm_adsp_buffer_alloc(struct wm_adsp *dsp)
1473 {
1474 struct wm_adsp_compr_buf *buf;
1475
1476 buf = kzalloc(sizeof(*buf), GFP_KERNEL);
1477 if (!buf)
1478 return NULL;
1479
1480 buf->dsp = dsp;
1481
1482 wm_adsp_buffer_clear(buf);
1483
1484 return buf;
1485 }
1486
wm_adsp_buffer_parse_legacy(struct wm_adsp * dsp)1487 static int wm_adsp_buffer_parse_legacy(struct wm_adsp *dsp)
1488 {
1489 struct cs_dsp_alg_region *alg_region;
1490 struct wm_adsp_compr_buf *buf;
1491 u32 xmalg, addr, magic;
1492 int i, ret;
1493
1494 alg_region = cs_dsp_find_alg_region(&dsp->cs_dsp, WMFW_ADSP2_XM, dsp->cs_dsp.fw_id);
1495 if (!alg_region) {
1496 adsp_err(dsp, "No algorithm region found\n");
1497 return -EINVAL;
1498 }
1499
1500 xmalg = dsp->sys_config_size / sizeof(__be32);
1501
1502 addr = alg_region->base + xmalg + ALG_XM_FIELD(magic);
1503 ret = cs_dsp_read_data_word(&dsp->cs_dsp, WMFW_ADSP2_XM, addr, &magic);
1504 if (ret < 0)
1505 return ret;
1506
1507 if (magic != WM_ADSP_ALG_XM_STRUCT_MAGIC)
1508 return -ENODEV;
1509
1510 buf = wm_adsp_buffer_alloc(dsp);
1511 if (!buf)
1512 return -ENOMEM;
1513
1514 addr = alg_region->base + xmalg + ALG_XM_FIELD(host_buf_ptr);
1515 for (i = 0; i < 5; ++i) {
1516 ret = cs_dsp_read_data_word(&dsp->cs_dsp, WMFW_ADSP2_XM, addr,
1517 &buf->host_buf_ptr);
1518 if (ret < 0)
1519 goto err;
1520
1521 if (buf->host_buf_ptr)
1522 break;
1523
1524 usleep_range(1000, 2000);
1525 }
1526
1527 if (!buf->host_buf_ptr) {
1528 ret = -EIO;
1529 goto err;
1530 }
1531
1532 buf->host_buf_mem_type = WMFW_ADSP2_XM;
1533
1534 ret = wm_adsp_buffer_populate(buf);
1535 if (ret < 0)
1536 goto err;
1537
1538 list_add_tail(&buf->list, &dsp->buffer_list);
1539
1540 compr_dbg(buf, "legacy host_buf_ptr=%x\n", buf->host_buf_ptr);
1541
1542 return 0;
1543
1544 err:
1545 kfree(buf);
1546
1547 return ret;
1548 }
1549
wm_adsp_buffer_parse_coeff(struct cs_dsp_coeff_ctl * cs_ctl)1550 static int wm_adsp_buffer_parse_coeff(struct cs_dsp_coeff_ctl *cs_ctl)
1551 {
1552 struct wm_adsp_host_buf_coeff_v1 coeff_v1;
1553 struct wm_adsp_compr_buf *buf;
1554 struct wm_adsp *dsp = container_of(cs_ctl->dsp, struct wm_adsp, cs_dsp);
1555 unsigned int version = 0;
1556 int ret, i;
1557
1558 for (i = 0; i < 5; ++i) {
1559 ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, &coeff_v1,
1560 min(cs_ctl->len, sizeof(coeff_v1)));
1561 if (ret < 0)
1562 return ret;
1563
1564 if (coeff_v1.host_buf_ptr)
1565 break;
1566
1567 usleep_range(1000, 2000);
1568 }
1569
1570 if (!coeff_v1.host_buf_ptr) {
1571 adsp_err(dsp, "Failed to acquire host buffer\n");
1572 return -EIO;
1573 }
1574
1575 buf = wm_adsp_buffer_alloc(dsp);
1576 if (!buf)
1577 return -ENOMEM;
1578
1579 buf->host_buf_mem_type = cs_ctl->alg_region.type;
1580 buf->host_buf_ptr = be32_to_cpu(coeff_v1.host_buf_ptr);
1581
1582 ret = wm_adsp_buffer_populate(buf);
1583 if (ret < 0)
1584 goto err;
1585
1586 /*
1587 * v0 host_buffer coefficients didn't have versioning, so if the
1588 * control is one word, assume version 0.
1589 */
1590 if (cs_ctl->len == 4)
1591 goto done;
1592
1593 version = be32_to_cpu(coeff_v1.versions) & HOST_BUF_COEFF_COMPAT_VER_MASK;
1594 version >>= HOST_BUF_COEFF_COMPAT_VER_SHIFT;
1595
1596 if (version > HOST_BUF_COEFF_SUPPORTED_COMPAT_VER) {
1597 adsp_err(dsp,
1598 "Host buffer coeff ver %u > supported version %u\n",
1599 version, HOST_BUF_COEFF_SUPPORTED_COMPAT_VER);
1600 ret = -EINVAL;
1601 goto err;
1602 }
1603
1604 cs_dsp_remove_padding((u32 *)&coeff_v1.name, ARRAY_SIZE(coeff_v1.name));
1605
1606 buf->name = kasprintf(GFP_KERNEL, "%s-dsp-%s", dsp->part,
1607 (char *)&coeff_v1.name);
1608
1609 done:
1610 list_add_tail(&buf->list, &dsp->buffer_list);
1611
1612 compr_dbg(buf, "host_buf_ptr=%x coeff version %u\n",
1613 buf->host_buf_ptr, version);
1614
1615 return version;
1616
1617 err:
1618 kfree(buf);
1619
1620 return ret;
1621 }
1622
wm_adsp_buffer_init(struct wm_adsp * dsp)1623 static int wm_adsp_buffer_init(struct wm_adsp *dsp)
1624 {
1625 struct cs_dsp_coeff_ctl *cs_ctl;
1626 int ret;
1627
1628 list_for_each_entry(cs_ctl, &dsp->cs_dsp.ctl_list, list) {
1629 if (cs_ctl->type != WMFW_CTL_TYPE_HOST_BUFFER)
1630 continue;
1631
1632 if (!cs_ctl->enabled)
1633 continue;
1634
1635 ret = wm_adsp_buffer_parse_coeff(cs_ctl);
1636 if (ret < 0) {
1637 adsp_err(dsp, "Failed to parse coeff: %d\n", ret);
1638 goto error;
1639 } else if (ret == 0) {
1640 /* Only one buffer supported for version 0 */
1641 return 0;
1642 }
1643 }
1644
1645 if (list_empty(&dsp->buffer_list)) {
1646 /* Fall back to legacy support */
1647 ret = wm_adsp_buffer_parse_legacy(dsp);
1648 if (ret == -ENODEV)
1649 adsp_info(dsp, "Legacy support not available\n");
1650 else if (ret)
1651 adsp_warn(dsp, "Failed to parse legacy: %d\n", ret);
1652 }
1653
1654 return 0;
1655
1656 error:
1657 wm_adsp_buffer_free(dsp);
1658 return ret;
1659 }
1660
wm_adsp_buffer_free(struct wm_adsp * dsp)1661 static int wm_adsp_buffer_free(struct wm_adsp *dsp)
1662 {
1663 struct wm_adsp_compr_buf *buf, *tmp;
1664
1665 list_for_each_entry_safe(buf, tmp, &dsp->buffer_list, list) {
1666 wm_adsp_compr_detach(buf->compr);
1667
1668 kfree(buf->name);
1669 kfree(buf->regions);
1670 list_del(&buf->list);
1671 kfree(buf);
1672 }
1673
1674 return 0;
1675 }
1676
wm_adsp_buffer_get_error(struct wm_adsp_compr_buf * buf)1677 static int wm_adsp_buffer_get_error(struct wm_adsp_compr_buf *buf)
1678 {
1679 int ret;
1680
1681 ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(error), &buf->error);
1682 if (ret < 0) {
1683 compr_err(buf, "Failed to check buffer error: %d\n", ret);
1684 return ret;
1685 }
1686 if (buf->error != 0) {
1687 compr_err(buf, "Buffer error occurred: %d\n", buf->error);
1688 return -EIO;
1689 }
1690
1691 return 0;
1692 }
1693
wm_adsp_compr_trigger(struct snd_soc_component * component,struct snd_compr_stream * stream,int cmd)1694 int wm_adsp_compr_trigger(struct snd_soc_component *component,
1695 struct snd_compr_stream *stream, int cmd)
1696 {
1697 struct wm_adsp_compr *compr = stream->runtime->private_data;
1698 struct wm_adsp *dsp = compr->dsp;
1699 int ret = 0;
1700
1701 compr_dbg(compr, "Trigger: %d\n", cmd);
1702
1703 mutex_lock(&dsp->cs_dsp.pwr_lock);
1704
1705 switch (cmd) {
1706 case SNDRV_PCM_TRIGGER_START:
1707 if (!wm_adsp_compr_attached(compr)) {
1708 ret = wm_adsp_compr_attach(compr);
1709 if (ret < 0) {
1710 compr_err(compr, "Failed to link buffer and stream: %d\n",
1711 ret);
1712 break;
1713 }
1714 }
1715
1716 ret = wm_adsp_buffer_get_error(compr->buf);
1717 if (ret < 0)
1718 break;
1719
1720 /* Trigger the IRQ at one fragment of data */
1721 ret = wm_adsp_buffer_write(compr->buf,
1722 HOST_BUFFER_FIELD(high_water_mark),
1723 wm_adsp_compr_frag_words(compr));
1724 if (ret < 0) {
1725 compr_err(compr, "Failed to set high water mark: %d\n",
1726 ret);
1727 break;
1728 }
1729 break;
1730 case SNDRV_PCM_TRIGGER_STOP:
1731 if (wm_adsp_compr_attached(compr))
1732 wm_adsp_buffer_clear(compr->buf);
1733 break;
1734 default:
1735 ret = -EINVAL;
1736 break;
1737 }
1738
1739 mutex_unlock(&dsp->cs_dsp.pwr_lock);
1740
1741 return ret;
1742 }
1743 EXPORT_SYMBOL_GPL(wm_adsp_compr_trigger);
1744
wm_adsp_buffer_size(struct wm_adsp_compr_buf * buf)1745 static inline int wm_adsp_buffer_size(struct wm_adsp_compr_buf *buf)
1746 {
1747 int last_region = wm_adsp_fw[buf->dsp->fw].caps->num_regions - 1;
1748
1749 return buf->regions[last_region].cumulative_size;
1750 }
1751
wm_adsp_buffer_update_avail(struct wm_adsp_compr_buf * buf)1752 static int wm_adsp_buffer_update_avail(struct wm_adsp_compr_buf *buf)
1753 {
1754 u32 next_read_index, next_write_index;
1755 int write_index, read_index, avail;
1756 int ret;
1757
1758 /* Only sync read index if we haven't already read a valid index */
1759 if (buf->read_index < 0) {
1760 ret = wm_adsp_buffer_read(buf,
1761 HOST_BUFFER_FIELD(next_read_index),
1762 &next_read_index);
1763 if (ret < 0)
1764 return ret;
1765
1766 read_index = sign_extend32(next_read_index, 23);
1767
1768 if (read_index < 0) {
1769 compr_dbg(buf, "Avail check on unstarted stream\n");
1770 return 0;
1771 }
1772
1773 buf->read_index = read_index;
1774 }
1775
1776 ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(next_write_index),
1777 &next_write_index);
1778 if (ret < 0)
1779 return ret;
1780
1781 write_index = sign_extend32(next_write_index, 23);
1782
1783 avail = write_index - buf->read_index;
1784 if (avail < 0)
1785 avail += wm_adsp_buffer_size(buf);
1786
1787 compr_dbg(buf, "readindex=0x%x, writeindex=0x%x, avail=%d\n",
1788 buf->read_index, write_index, avail * CS_DSP_DATA_WORD_SIZE);
1789
1790 buf->avail = avail;
1791
1792 return 0;
1793 }
1794
wm_adsp_compr_handle_irq(struct wm_adsp * dsp)1795 int wm_adsp_compr_handle_irq(struct wm_adsp *dsp)
1796 {
1797 struct wm_adsp_compr_buf *buf;
1798 struct wm_adsp_compr *compr;
1799 int ret = 0;
1800
1801 mutex_lock(&dsp->cs_dsp.pwr_lock);
1802
1803 if (list_empty(&dsp->buffer_list)) {
1804 ret = -ENODEV;
1805 goto out;
1806 }
1807
1808 adsp_dbg(dsp, "Handling buffer IRQ\n");
1809
1810 list_for_each_entry(buf, &dsp->buffer_list, list) {
1811 compr = buf->compr;
1812
1813 ret = wm_adsp_buffer_get_error(buf);
1814 if (ret < 0)
1815 goto out_notify; /* Wake poll to report error */
1816
1817 ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(irq_count),
1818 &buf->irq_count);
1819 if (ret < 0) {
1820 compr_err(buf, "Failed to get irq_count: %d\n", ret);
1821 goto out;
1822 }
1823
1824 ret = wm_adsp_buffer_update_avail(buf);
1825 if (ret < 0) {
1826 compr_err(buf, "Error reading avail: %d\n", ret);
1827 goto out;
1828 }
1829
1830 if (wm_adsp_fw[dsp->fw].voice_trigger && buf->irq_count == 2)
1831 ret = WM_ADSP_COMPR_VOICE_TRIGGER;
1832
1833 out_notify:
1834 if (compr && compr->stream)
1835 snd_compr_fragment_elapsed(compr->stream);
1836 }
1837
1838 out:
1839 mutex_unlock(&dsp->cs_dsp.pwr_lock);
1840
1841 return ret;
1842 }
1843 EXPORT_SYMBOL_GPL(wm_adsp_compr_handle_irq);
1844
wm_adsp_buffer_reenable_irq(struct wm_adsp_compr_buf * buf)1845 static int wm_adsp_buffer_reenable_irq(struct wm_adsp_compr_buf *buf)
1846 {
1847 if (buf->irq_count & 0x01)
1848 return 0;
1849
1850 compr_dbg(buf, "Enable IRQ(0x%x) for next fragment\n", buf->irq_count);
1851
1852 buf->irq_count |= 0x01;
1853
1854 return wm_adsp_buffer_write(buf, HOST_BUFFER_FIELD(irq_ack),
1855 buf->irq_count);
1856 }
1857
wm_adsp_compr_pointer(struct snd_soc_component * component,struct snd_compr_stream * stream,struct snd_compr_tstamp * tstamp)1858 int wm_adsp_compr_pointer(struct snd_soc_component *component,
1859 struct snd_compr_stream *stream,
1860 struct snd_compr_tstamp *tstamp)
1861 {
1862 struct wm_adsp_compr *compr = stream->runtime->private_data;
1863 struct wm_adsp *dsp = compr->dsp;
1864 struct wm_adsp_compr_buf *buf;
1865 int ret = 0;
1866
1867 compr_dbg(compr, "Pointer request\n");
1868
1869 mutex_lock(&dsp->cs_dsp.pwr_lock);
1870
1871 buf = compr->buf;
1872
1873 if (dsp->fatal_error || !buf || buf->error) {
1874 snd_compr_stop_error(stream, SNDRV_PCM_STATE_XRUN);
1875 ret = -EIO;
1876 goto out;
1877 }
1878
1879 if (buf->avail < wm_adsp_compr_frag_words(compr)) {
1880 ret = wm_adsp_buffer_update_avail(buf);
1881 if (ret < 0) {
1882 compr_err(compr, "Error reading avail: %d\n", ret);
1883 goto out;
1884 }
1885
1886 /*
1887 * If we really have less than 1 fragment available tell the
1888 * DSP to inform us once a whole fragment is available.
1889 */
1890 if (buf->avail < wm_adsp_compr_frag_words(compr)) {
1891 ret = wm_adsp_buffer_get_error(buf);
1892 if (ret < 0) {
1893 if (buf->error)
1894 snd_compr_stop_error(stream,
1895 SNDRV_PCM_STATE_XRUN);
1896 goto out;
1897 }
1898
1899 ret = wm_adsp_buffer_reenable_irq(buf);
1900 if (ret < 0) {
1901 compr_err(compr, "Failed to re-enable buffer IRQ: %d\n",
1902 ret);
1903 goto out;
1904 }
1905 }
1906 }
1907
1908 tstamp->copied_total = compr->copied_total;
1909 tstamp->copied_total += buf->avail * CS_DSP_DATA_WORD_SIZE;
1910 tstamp->sampling_rate = compr->sample_rate;
1911
1912 out:
1913 mutex_unlock(&dsp->cs_dsp.pwr_lock);
1914
1915 return ret;
1916 }
1917 EXPORT_SYMBOL_GPL(wm_adsp_compr_pointer);
1918
wm_adsp_buffer_capture_block(struct wm_adsp_compr * compr,int target)1919 static int wm_adsp_buffer_capture_block(struct wm_adsp_compr *compr, int target)
1920 {
1921 struct wm_adsp_compr_buf *buf = compr->buf;
1922 unsigned int adsp_addr;
1923 int mem_type, nwords, max_read;
1924 int i, ret;
1925
1926 /* Calculate read parameters */
1927 for (i = 0; i < wm_adsp_fw[buf->dsp->fw].caps->num_regions; ++i)
1928 if (buf->read_index < buf->regions[i].cumulative_size)
1929 break;
1930
1931 if (i == wm_adsp_fw[buf->dsp->fw].caps->num_regions)
1932 return -EINVAL;
1933
1934 mem_type = buf->regions[i].mem_type;
1935 adsp_addr = buf->regions[i].base_addr +
1936 (buf->read_index - buf->regions[i].offset);
1937
1938 max_read = wm_adsp_compr_frag_words(compr);
1939 nwords = buf->regions[i].cumulative_size - buf->read_index;
1940
1941 if (nwords > target)
1942 nwords = target;
1943 if (nwords > buf->avail)
1944 nwords = buf->avail;
1945 if (nwords > max_read)
1946 nwords = max_read;
1947 if (!nwords)
1948 return 0;
1949
1950 /* Read data from DSP */
1951 ret = cs_dsp_read_raw_data_block(&buf->dsp->cs_dsp, mem_type, adsp_addr,
1952 nwords, (__be32 *)compr->raw_buf);
1953 if (ret < 0)
1954 return ret;
1955
1956 cs_dsp_remove_padding(compr->raw_buf, nwords);
1957
1958 /* update read index to account for words read */
1959 buf->read_index += nwords;
1960 if (buf->read_index == wm_adsp_buffer_size(buf))
1961 buf->read_index = 0;
1962
1963 ret = wm_adsp_buffer_write(buf, HOST_BUFFER_FIELD(next_read_index),
1964 buf->read_index);
1965 if (ret < 0)
1966 return ret;
1967
1968 /* update avail to account for words read */
1969 buf->avail -= nwords;
1970
1971 return nwords;
1972 }
1973
wm_adsp_compr_read(struct wm_adsp_compr * compr,char __user * buf,size_t count)1974 static int wm_adsp_compr_read(struct wm_adsp_compr *compr,
1975 char __user *buf, size_t count)
1976 {
1977 struct wm_adsp *dsp = compr->dsp;
1978 int ntotal = 0;
1979 int nwords, nbytes;
1980
1981 compr_dbg(compr, "Requested read of %zu bytes\n", count);
1982
1983 if (dsp->fatal_error || !compr->buf || compr->buf->error) {
1984 snd_compr_stop_error(compr->stream, SNDRV_PCM_STATE_XRUN);
1985 return -EIO;
1986 }
1987
1988 count /= CS_DSP_DATA_WORD_SIZE;
1989
1990 do {
1991 nwords = wm_adsp_buffer_capture_block(compr, count);
1992 if (nwords < 0) {
1993 compr_err(compr, "Failed to capture block: %d\n",
1994 nwords);
1995 return nwords;
1996 }
1997
1998 nbytes = nwords * CS_DSP_DATA_WORD_SIZE;
1999
2000 compr_dbg(compr, "Read %d bytes\n", nbytes);
2001
2002 if (copy_to_user(buf + ntotal, compr->raw_buf, nbytes)) {
2003 compr_err(compr, "Failed to copy data to user: %d, %d\n",
2004 ntotal, nbytes);
2005 return -EFAULT;
2006 }
2007
2008 count -= nwords;
2009 ntotal += nbytes;
2010 } while (nwords > 0 && count > 0);
2011
2012 compr->copied_total += ntotal;
2013
2014 return ntotal;
2015 }
2016
wm_adsp_compr_copy(struct snd_soc_component * component,struct snd_compr_stream * stream,char __user * buf,size_t count)2017 int wm_adsp_compr_copy(struct snd_soc_component *component,
2018 struct snd_compr_stream *stream, char __user *buf,
2019 size_t count)
2020 {
2021 struct wm_adsp_compr *compr = stream->runtime->private_data;
2022 struct wm_adsp *dsp = compr->dsp;
2023 int ret;
2024
2025 mutex_lock(&dsp->cs_dsp.pwr_lock);
2026
2027 if (stream->direction == SND_COMPRESS_CAPTURE)
2028 ret = wm_adsp_compr_read(compr, buf, count);
2029 else
2030 ret = -ENOTSUPP;
2031
2032 mutex_unlock(&dsp->cs_dsp.pwr_lock);
2033
2034 return ret;
2035 }
2036 EXPORT_SYMBOL_GPL(wm_adsp_compr_copy);
2037
wm_adsp_fatal_error(struct cs_dsp * cs_dsp)2038 static void wm_adsp_fatal_error(struct cs_dsp *cs_dsp)
2039 {
2040 struct wm_adsp *dsp = container_of(cs_dsp, struct wm_adsp, cs_dsp);
2041 struct wm_adsp_compr *compr;
2042
2043 dsp->fatal_error = true;
2044
2045 list_for_each_entry(compr, &dsp->compr_list, list) {
2046 if (compr->stream)
2047 snd_compr_fragment_elapsed(compr->stream);
2048 }
2049 }
2050
wm_adsp2_bus_error(int irq,void * data)2051 irqreturn_t wm_adsp2_bus_error(int irq, void *data)
2052 {
2053 struct wm_adsp *dsp = (struct wm_adsp *)data;
2054
2055 cs_dsp_adsp2_bus_error(&dsp->cs_dsp);
2056
2057 return IRQ_HANDLED;
2058 }
2059 EXPORT_SYMBOL_GPL(wm_adsp2_bus_error);
2060
wm_halo_bus_error(int irq,void * data)2061 irqreturn_t wm_halo_bus_error(int irq, void *data)
2062 {
2063 struct wm_adsp *dsp = (struct wm_adsp *)data;
2064
2065 cs_dsp_halo_bus_error(&dsp->cs_dsp);
2066
2067 return IRQ_HANDLED;
2068 }
2069 EXPORT_SYMBOL_GPL(wm_halo_bus_error);
2070
wm_halo_wdt_expire(int irq,void * data)2071 irqreturn_t wm_halo_wdt_expire(int irq, void *data)
2072 {
2073 struct wm_adsp *dsp = data;
2074
2075 cs_dsp_halo_wdt_expire(&dsp->cs_dsp);
2076
2077 return IRQ_HANDLED;
2078 }
2079 EXPORT_SYMBOL_GPL(wm_halo_wdt_expire);
2080
2081 static const struct cs_dsp_client_ops wm_adsp1_client_ops = {
2082 .control_add = wm_adsp_control_add,
2083 .control_remove = wm_adsp_control_remove,
2084 };
2085
2086 static const struct cs_dsp_client_ops wm_adsp2_client_ops = {
2087 .control_add = wm_adsp_control_add,
2088 .control_remove = wm_adsp_control_remove,
2089 .pre_run = wm_adsp_pre_run,
2090 .post_run = wm_adsp_event_post_run,
2091 .post_stop = wm_adsp_event_post_stop,
2092 .watchdog_expired = wm_adsp_fatal_error,
2093 };
2094
2095 MODULE_LICENSE("GPL v2");
2096 MODULE_IMPORT_NS(FW_CS_DSP);
2097