2 * wm_adsp.c -- Wolfson ADSP support
4 * Copyright 2012 Wolfson Microelectronics plc
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/ctype.h>
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
18 #include <linux/firmware.h>
19 #include <linux/list.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/regmap.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/slab.h>
25 #include <linux/vmalloc.h>
26 #include <linux/workqueue.h>
27 #include <linux/debugfs.h>
28 #include <sound/core.h>
29 #include <sound/pcm.h>
30 #include <sound/pcm_params.h>
31 #include <sound/soc.h>
32 #include <sound/jack.h>
33 #include <sound/initval.h>
34 #include <sound/tlv.h>
38 #define adsp_crit(_dsp, fmt, ...) \
39 dev_crit(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__)
40 #define adsp_err(_dsp, fmt, ...) \
41 dev_err(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__)
42 #define adsp_warn(_dsp, fmt, ...) \
43 dev_warn(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__)
44 #define adsp_info(_dsp, fmt, ...) \
45 dev_info(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__)
46 #define adsp_dbg(_dsp, fmt, ...) \
47 dev_dbg(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__)
49 #define ADSP1_CONTROL_1 0x00
50 #define ADSP1_CONTROL_2 0x02
51 #define ADSP1_CONTROL_3 0x03
52 #define ADSP1_CONTROL_4 0x04
53 #define ADSP1_CONTROL_5 0x06
54 #define ADSP1_CONTROL_6 0x07
55 #define ADSP1_CONTROL_7 0x08
56 #define ADSP1_CONTROL_8 0x09
57 #define ADSP1_CONTROL_9 0x0A
58 #define ADSP1_CONTROL_10 0x0B
59 #define ADSP1_CONTROL_11 0x0C
60 #define ADSP1_CONTROL_12 0x0D
61 #define ADSP1_CONTROL_13 0x0F
62 #define ADSP1_CONTROL_14 0x10
63 #define ADSP1_CONTROL_15 0x11
64 #define ADSP1_CONTROL_16 0x12
65 #define ADSP1_CONTROL_17 0x13
66 #define ADSP1_CONTROL_18 0x14
67 #define ADSP1_CONTROL_19 0x16
68 #define ADSP1_CONTROL_20 0x17
69 #define ADSP1_CONTROL_21 0x18
70 #define ADSP1_CONTROL_22 0x1A
71 #define ADSP1_CONTROL_23 0x1B
72 #define ADSP1_CONTROL_24 0x1C
73 #define ADSP1_CONTROL_25 0x1E
74 #define ADSP1_CONTROL_26 0x20
75 #define ADSP1_CONTROL_27 0x21
76 #define ADSP1_CONTROL_28 0x22
77 #define ADSP1_CONTROL_29 0x23
78 #define ADSP1_CONTROL_30 0x24
79 #define ADSP1_CONTROL_31 0x26
84 #define ADSP1_WDMA_BUFFER_LENGTH_MASK 0x00FF /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */
85 #define ADSP1_WDMA_BUFFER_LENGTH_SHIFT 0 /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */
86 #define ADSP1_WDMA_BUFFER_LENGTH_WIDTH 8 /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */
92 #define ADSP1_DBG_CLK_ENA 0x0008 /* DSP1_DBG_CLK_ENA */
93 #define ADSP1_DBG_CLK_ENA_MASK 0x0008 /* DSP1_DBG_CLK_ENA */
94 #define ADSP1_DBG_CLK_ENA_SHIFT 3 /* DSP1_DBG_CLK_ENA */
95 #define ADSP1_DBG_CLK_ENA_WIDTH 1 /* DSP1_DBG_CLK_ENA */
96 #define ADSP1_SYS_ENA 0x0004 /* DSP1_SYS_ENA */
97 #define ADSP1_SYS_ENA_MASK 0x0004 /* DSP1_SYS_ENA */
98 #define ADSP1_SYS_ENA_SHIFT 2 /* DSP1_SYS_ENA */
99 #define ADSP1_SYS_ENA_WIDTH 1 /* DSP1_SYS_ENA */
100 #define ADSP1_CORE_ENA 0x0002 /* DSP1_CORE_ENA */
101 #define ADSP1_CORE_ENA_MASK 0x0002 /* DSP1_CORE_ENA */
102 #define ADSP1_CORE_ENA_SHIFT 1 /* DSP1_CORE_ENA */
103 #define ADSP1_CORE_ENA_WIDTH 1 /* DSP1_CORE_ENA */
104 #define ADSP1_START 0x0001 /* DSP1_START */
105 #define ADSP1_START_MASK 0x0001 /* DSP1_START */
106 #define ADSP1_START_SHIFT 0 /* DSP1_START */
107 #define ADSP1_START_WIDTH 1 /* DSP1_START */
112 #define ADSP1_CLK_SEL_MASK 0x0007 /* CLK_SEL_ENA */
113 #define ADSP1_CLK_SEL_SHIFT 0 /* CLK_SEL_ENA */
114 #define ADSP1_CLK_SEL_WIDTH 3 /* CLK_SEL_ENA */
116 #define ADSP2_CONTROL 0x0
117 #define ADSP2_CLOCKING 0x1
118 #define ADSP2V2_CLOCKING 0x2
119 #define ADSP2_STATUS1 0x4
120 #define ADSP2_WDMA_CONFIG_1 0x30
121 #define ADSP2_WDMA_CONFIG_2 0x31
122 #define ADSP2V2_WDMA_CONFIG_2 0x32
123 #define ADSP2_RDMA_CONFIG_1 0x34
125 #define ADSP2_SCRATCH0 0x40
126 #define ADSP2_SCRATCH1 0x41
127 #define ADSP2_SCRATCH2 0x42
128 #define ADSP2_SCRATCH3 0x43
130 #define ADSP2V2_SCRATCH0_1 0x40
131 #define ADSP2V2_SCRATCH2_3 0x42
137 #define ADSP2_MEM_ENA 0x0010 /* DSP1_MEM_ENA */
138 #define ADSP2_MEM_ENA_MASK 0x0010 /* DSP1_MEM_ENA */
139 #define ADSP2_MEM_ENA_SHIFT 4 /* DSP1_MEM_ENA */
140 #define ADSP2_MEM_ENA_WIDTH 1 /* DSP1_MEM_ENA */
141 #define ADSP2_SYS_ENA 0x0004 /* DSP1_SYS_ENA */
142 #define ADSP2_SYS_ENA_MASK 0x0004 /* DSP1_SYS_ENA */
143 #define ADSP2_SYS_ENA_SHIFT 2 /* DSP1_SYS_ENA */
144 #define ADSP2_SYS_ENA_WIDTH 1 /* DSP1_SYS_ENA */
145 #define ADSP2_CORE_ENA 0x0002 /* DSP1_CORE_ENA */
146 #define ADSP2_CORE_ENA_MASK 0x0002 /* DSP1_CORE_ENA */
147 #define ADSP2_CORE_ENA_SHIFT 1 /* DSP1_CORE_ENA */
148 #define ADSP2_CORE_ENA_WIDTH 1 /* DSP1_CORE_ENA */
149 #define ADSP2_START 0x0001 /* DSP1_START */
150 #define ADSP2_START_MASK 0x0001 /* DSP1_START */
151 #define ADSP2_START_SHIFT 0 /* DSP1_START */
152 #define ADSP2_START_WIDTH 1 /* DSP1_START */
157 #define ADSP2_CLK_SEL_MASK 0x0007 /* CLK_SEL_ENA */
158 #define ADSP2_CLK_SEL_SHIFT 0 /* CLK_SEL_ENA */
159 #define ADSP2_CLK_SEL_WIDTH 3 /* CLK_SEL_ENA */
164 #define ADSP2V2_CLK_SEL_MASK 0x70000 /* CLK_SEL_ENA */
165 #define ADSP2V2_CLK_SEL_SHIFT 16 /* CLK_SEL_ENA */
166 #define ADSP2V2_CLK_SEL_WIDTH 3 /* CLK_SEL_ENA */
168 #define ADSP2V2_RATE_MASK 0x7800 /* DSP_RATE */
169 #define ADSP2V2_RATE_SHIFT 11 /* DSP_RATE */
170 #define ADSP2V2_RATE_WIDTH 4 /* DSP_RATE */
175 #define ADSP2_RAM_RDY 0x0001
176 #define ADSP2_RAM_RDY_MASK 0x0001
177 #define ADSP2_RAM_RDY_SHIFT 0
178 #define ADSP2_RAM_RDY_WIDTH 1
183 #define ADSP2_LOCK_CODE_0 0x5555
184 #define ADSP2_LOCK_CODE_1 0xAAAA
186 #define ADSP2_WATCHDOG 0x0A
187 #define ADSP2_BUS_ERR_ADDR 0x52
188 #define ADSP2_REGION_LOCK_STATUS 0x64
189 #define ADSP2_LOCK_REGION_1_LOCK_REGION_0 0x66
190 #define ADSP2_LOCK_REGION_3_LOCK_REGION_2 0x68
191 #define ADSP2_LOCK_REGION_5_LOCK_REGION_4 0x6A
192 #define ADSP2_LOCK_REGION_7_LOCK_REGION_6 0x6C
193 #define ADSP2_LOCK_REGION_9_LOCK_REGION_8 0x6E
194 #define ADSP2_LOCK_REGION_CTRL 0x7A
195 #define ADSP2_PMEM_ERR_ADDR_XMEM_ERR_ADDR 0x7C
197 #define ADSP2_REGION_LOCK_ERR_MASK 0x8000
198 #define ADSP2_SLAVE_ERR_MASK 0x4000
199 #define ADSP2_WDT_TIMEOUT_STS_MASK 0x2000
200 #define ADSP2_CTRL_ERR_PAUSE_ENA 0x0002
201 #define ADSP2_CTRL_ERR_EINT 0x0001
203 #define ADSP2_BUS_ERR_ADDR_MASK 0x00FFFFFF
204 #define ADSP2_XMEM_ERR_ADDR_MASK 0x0000FFFF
205 #define ADSP2_PMEM_ERR_ADDR_MASK 0x7FFF0000
206 #define ADSP2_PMEM_ERR_ADDR_SHIFT 16
207 #define ADSP2_WDT_ENA_MASK 0xFFFFFFFD
209 #define ADSP2_LOCK_REGION_SHIFT 16
211 #define ADSP_MAX_STD_CTRL_SIZE 512
213 #define WM_ADSP_ACKED_CTL_TIMEOUT_MS 100
214 #define WM_ADSP_ACKED_CTL_N_QUICKPOLLS 10
215 #define WM_ADSP_ACKED_CTL_MIN_VALUE 0
216 #define WM_ADSP_ACKED_CTL_MAX_VALUE 0xFFFFFF
219 * Event control messages
221 #define WM_ADSP_FW_EVENT_SHUTDOWN 0x000001
224 struct list_head list
;
228 static struct wm_adsp_buf
*wm_adsp_buf_alloc(const void *src
, size_t len
,
229 struct list_head
*list
)
231 struct wm_adsp_buf
*buf
= kzalloc(sizeof(*buf
), GFP_KERNEL
);
236 buf
->buf
= vmalloc(len
);
241 memcpy(buf
->buf
, src
, len
);
244 list_add_tail(&buf
->list
, list
);
249 static void wm_adsp_buf_free(struct list_head
*list
)
251 while (!list_empty(list
)) {
252 struct wm_adsp_buf
*buf
= list_first_entry(list
,
255 list_del(&buf
->list
);
261 #define WM_ADSP_FW_MBC_VSS 0
262 #define WM_ADSP_FW_HIFI 1
263 #define WM_ADSP_FW_TX 2
264 #define WM_ADSP_FW_TX_SPK 3
265 #define WM_ADSP_FW_RX 4
266 #define WM_ADSP_FW_RX_ANC 5
267 #define WM_ADSP_FW_CTRL 6
268 #define WM_ADSP_FW_ASR 7
269 #define WM_ADSP_FW_TRACE 8
270 #define WM_ADSP_FW_SPK_PROT 9
271 #define WM_ADSP_FW_MISC 10
273 #define WM_ADSP_NUM_FW 11
275 static const char *wm_adsp_fw_text
[WM_ADSP_NUM_FW
] = {
276 [WM_ADSP_FW_MBC_VSS
] = "MBC/VSS",
277 [WM_ADSP_FW_HIFI
] = "MasterHiFi",
278 [WM_ADSP_FW_TX
] = "Tx",
279 [WM_ADSP_FW_TX_SPK
] = "Tx Speaker",
280 [WM_ADSP_FW_RX
] = "Rx",
281 [WM_ADSP_FW_RX_ANC
] = "Rx ANC",
282 [WM_ADSP_FW_CTRL
] = "Voice Ctrl",
283 [WM_ADSP_FW_ASR
] = "ASR Assist",
284 [WM_ADSP_FW_TRACE
] = "Dbg Trace",
285 [WM_ADSP_FW_SPK_PROT
] = "Protection",
286 [WM_ADSP_FW_MISC
] = "Misc",
289 struct wm_adsp_system_config_xm_hdr
{
295 __be32 dma_buffer_size
;
298 __be32 build_job_name
[3];
299 __be32 build_job_number
;
302 struct wm_adsp_alg_xm_struct
{
308 __be32 high_water_mark
;
309 __be32 low_water_mark
;
310 __be64 smoothed_power
;
313 struct wm_adsp_buffer
{
314 __be32 X_buf_base
; /* XM base addr of first X area */
315 __be32 X_buf_size
; /* Size of 1st X area in words */
316 __be32 X_buf_base2
; /* XM base addr of 2nd X area */
317 __be32 X_buf_brk
; /* Total X size in words */
318 __be32 Y_buf_base
; /* YM base addr of Y area */
319 __be32 wrap
; /* Total size X and Y in words */
320 __be32 high_water_mark
; /* Point at which IRQ is asserted */
321 __be32 irq_count
; /* bits 1-31 count IRQ assertions */
322 __be32 irq_ack
; /* acked IRQ count, bit 0 enables IRQ */
323 __be32 next_write_index
; /* word index of next write */
324 __be32 next_read_index
; /* word index of next read */
325 __be32 error
; /* error if any */
326 __be32 oldest_block_index
; /* word index of oldest surviving */
327 __be32 requested_rewind
; /* how many blocks rewind was done */
328 __be32 reserved_space
; /* internal */
329 __be32 min_free
; /* min free space since stream start */
330 __be32 blocks_written
[2]; /* total blocks written (64 bit) */
331 __be32 words_written
[2]; /* total words written (64 bit) */
334 struct wm_adsp_compr
;
336 struct wm_adsp_compr_buf
{
338 struct wm_adsp_compr
*compr
;
340 struct wm_adsp_buffer_region
*regions
;
349 struct wm_adsp_compr
{
351 struct wm_adsp_compr_buf
*buf
;
353 struct snd_compr_stream
*stream
;
354 struct snd_compressed_buffer size
;
357 unsigned int copied_total
;
359 unsigned int sample_rate
;
362 #define WM_ADSP_DATA_WORD_SIZE 3
364 #define WM_ADSP_MIN_FRAGMENTS 1
365 #define WM_ADSP_MAX_FRAGMENTS 256
366 #define WM_ADSP_MIN_FRAGMENT_SIZE (64 * WM_ADSP_DATA_WORD_SIZE)
367 #define WM_ADSP_MAX_FRAGMENT_SIZE (4096 * WM_ADSP_DATA_WORD_SIZE)
369 #define WM_ADSP_ALG_XM_STRUCT_MAGIC 0x49aec7
371 #define HOST_BUFFER_FIELD(field) \
372 (offsetof(struct wm_adsp_buffer, field) / sizeof(__be32))
374 #define ALG_XM_FIELD(field) \
375 (offsetof(struct wm_adsp_alg_xm_struct, field) / sizeof(__be32))
377 static int wm_adsp_buffer_init(struct wm_adsp
*dsp
);
378 static int wm_adsp_buffer_free(struct wm_adsp
*dsp
);
380 struct wm_adsp_buffer_region
{
382 unsigned int cumulative_size
;
383 unsigned int mem_type
;
384 unsigned int base_addr
;
387 struct wm_adsp_buffer_region_def
{
388 unsigned int mem_type
;
389 unsigned int base_offset
;
390 unsigned int size_offset
;
393 static const struct wm_adsp_buffer_region_def default_regions
[] = {
395 .mem_type
= WMFW_ADSP2_XM
,
396 .base_offset
= HOST_BUFFER_FIELD(X_buf_base
),
397 .size_offset
= HOST_BUFFER_FIELD(X_buf_size
),
400 .mem_type
= WMFW_ADSP2_XM
,
401 .base_offset
= HOST_BUFFER_FIELD(X_buf_base2
),
402 .size_offset
= HOST_BUFFER_FIELD(X_buf_brk
),
405 .mem_type
= WMFW_ADSP2_YM
,
406 .base_offset
= HOST_BUFFER_FIELD(Y_buf_base
),
407 .size_offset
= HOST_BUFFER_FIELD(wrap
),
411 struct wm_adsp_fw_caps
{
413 struct snd_codec_desc desc
;
415 const struct wm_adsp_buffer_region_def
*region_defs
;
418 static const struct wm_adsp_fw_caps ctrl_caps
[] = {
420 .id
= SND_AUDIOCODEC_BESPOKE
,
423 .sample_rates
= { 16000 },
424 .num_sample_rates
= 1,
425 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
427 .num_regions
= ARRAY_SIZE(default_regions
),
428 .region_defs
= default_regions
,
432 static const struct wm_adsp_fw_caps trace_caps
[] = {
434 .id
= SND_AUDIOCODEC_BESPOKE
,
438 4000, 8000, 11025, 12000, 16000, 22050,
439 24000, 32000, 44100, 48000, 64000, 88200,
440 96000, 176400, 192000
442 .num_sample_rates
= 15,
443 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
445 .num_regions
= ARRAY_SIZE(default_regions
),
446 .region_defs
= default_regions
,
450 static const struct {
454 const struct wm_adsp_fw_caps
*caps
;
456 } wm_adsp_fw
[WM_ADSP_NUM_FW
] = {
457 [WM_ADSP_FW_MBC_VSS
] = { .file
= "mbc-vss" },
458 [WM_ADSP_FW_HIFI
] = { .file
= "hifi" },
459 [WM_ADSP_FW_TX
] = { .file
= "tx" },
460 [WM_ADSP_FW_TX_SPK
] = { .file
= "tx-spk" },
461 [WM_ADSP_FW_RX
] = { .file
= "rx" },
462 [WM_ADSP_FW_RX_ANC
] = { .file
= "rx-anc" },
463 [WM_ADSP_FW_CTRL
] = {
465 .compr_direction
= SND_COMPRESS_CAPTURE
,
466 .num_caps
= ARRAY_SIZE(ctrl_caps
),
468 .voice_trigger
= true,
470 [WM_ADSP_FW_ASR
] = { .file
= "asr" },
471 [WM_ADSP_FW_TRACE
] = {
473 .compr_direction
= SND_COMPRESS_CAPTURE
,
474 .num_caps
= ARRAY_SIZE(trace_caps
),
477 [WM_ADSP_FW_SPK_PROT
] = { .file
= "spk-prot" },
478 [WM_ADSP_FW_MISC
] = { .file
= "misc" },
481 struct wm_coeff_ctl_ops
{
482 int (*xget
)(struct snd_kcontrol
*kcontrol
,
483 struct snd_ctl_elem_value
*ucontrol
);
484 int (*xput
)(struct snd_kcontrol
*kcontrol
,
485 struct snd_ctl_elem_value
*ucontrol
);
488 struct wm_coeff_ctl
{
491 struct wm_adsp_alg_region alg_region
;
492 struct wm_coeff_ctl_ops ops
;
494 unsigned int enabled
:1;
495 struct list_head list
;
500 struct soc_bytes_ext bytes_ext
;
505 static const char *wm_adsp_mem_region_name(unsigned int type
)
523 #ifdef CONFIG_DEBUG_FS
524 static void wm_adsp_debugfs_save_wmfwname(struct wm_adsp
*dsp
, const char *s
)
526 char *tmp
= kasprintf(GFP_KERNEL
, "%s\n", s
);
528 kfree(dsp
->wmfw_file_name
);
529 dsp
->wmfw_file_name
= tmp
;
532 static void wm_adsp_debugfs_save_binname(struct wm_adsp
*dsp
, const char *s
)
534 char *tmp
= kasprintf(GFP_KERNEL
, "%s\n", s
);
536 kfree(dsp
->bin_file_name
);
537 dsp
->bin_file_name
= tmp
;
540 static void wm_adsp_debugfs_clear(struct wm_adsp
*dsp
)
542 kfree(dsp
->wmfw_file_name
);
543 kfree(dsp
->bin_file_name
);
544 dsp
->wmfw_file_name
= NULL
;
545 dsp
->bin_file_name
= NULL
;
548 static ssize_t
wm_adsp_debugfs_wmfw_read(struct file
*file
,
549 char __user
*user_buf
,
550 size_t count
, loff_t
*ppos
)
552 struct wm_adsp
*dsp
= file
->private_data
;
555 mutex_lock(&dsp
->pwr_lock
);
557 if (!dsp
->wmfw_file_name
|| !dsp
->booted
)
560 ret
= simple_read_from_buffer(user_buf
, count
, ppos
,
562 strlen(dsp
->wmfw_file_name
));
564 mutex_unlock(&dsp
->pwr_lock
);
568 static ssize_t
wm_adsp_debugfs_bin_read(struct file
*file
,
569 char __user
*user_buf
,
570 size_t count
, loff_t
*ppos
)
572 struct wm_adsp
*dsp
= file
->private_data
;
575 mutex_lock(&dsp
->pwr_lock
);
577 if (!dsp
->bin_file_name
|| !dsp
->booted
)
580 ret
= simple_read_from_buffer(user_buf
, count
, ppos
,
582 strlen(dsp
->bin_file_name
));
584 mutex_unlock(&dsp
->pwr_lock
);
588 static const struct {
590 const struct file_operations fops
;
591 } wm_adsp_debugfs_fops
[] = {
593 .name
= "wmfw_file_name",
596 .read
= wm_adsp_debugfs_wmfw_read
,
600 .name
= "bin_file_name",
603 .read
= wm_adsp_debugfs_bin_read
,
608 static void wm_adsp2_init_debugfs(struct wm_adsp
*dsp
,
609 struct snd_soc_component
*component
)
611 struct dentry
*root
= NULL
;
614 if (!component
->debugfs_root
) {
615 adsp_err(dsp
, "No codec debugfs root\n");
619 root
= debugfs_create_dir(dsp
->name
, component
->debugfs_root
);
624 if (!debugfs_create_bool("booted", 0444, root
, &dsp
->booted
))
627 if (!debugfs_create_bool("running", 0444, root
, &dsp
->running
))
630 if (!debugfs_create_x32("fw_id", 0444, root
, &dsp
->fw_id
))
633 if (!debugfs_create_x32("fw_version", 0444, root
, &dsp
->fw_id_version
))
636 for (i
= 0; i
< ARRAY_SIZE(wm_adsp_debugfs_fops
); ++i
) {
637 if (!debugfs_create_file(wm_adsp_debugfs_fops
[i
].name
,
639 &wm_adsp_debugfs_fops
[i
].fops
))
643 dsp
->debugfs_root
= root
;
647 debugfs_remove_recursive(root
);
648 adsp_err(dsp
, "Failed to create debugfs\n");
651 static void wm_adsp2_cleanup_debugfs(struct wm_adsp
*dsp
)
653 wm_adsp_debugfs_clear(dsp
);
654 debugfs_remove_recursive(dsp
->debugfs_root
);
657 static inline void wm_adsp2_init_debugfs(struct wm_adsp
*dsp
,
658 struct snd_soc_component
*component
)
662 static inline void wm_adsp2_cleanup_debugfs(struct wm_adsp
*dsp
)
666 static inline void wm_adsp_debugfs_save_wmfwname(struct wm_adsp
*dsp
,
671 static inline void wm_adsp_debugfs_save_binname(struct wm_adsp
*dsp
,
676 static inline void wm_adsp_debugfs_clear(struct wm_adsp
*dsp
)
681 int wm_adsp_fw_get(struct snd_kcontrol
*kcontrol
,
682 struct snd_ctl_elem_value
*ucontrol
)
684 struct snd_soc_component
*component
= snd_soc_kcontrol_component(kcontrol
);
685 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
686 struct wm_adsp
*dsp
= snd_soc_component_get_drvdata(component
);
688 ucontrol
->value
.enumerated
.item
[0] = dsp
[e
->shift_l
].fw
;
692 EXPORT_SYMBOL_GPL(wm_adsp_fw_get
);
694 int wm_adsp_fw_put(struct snd_kcontrol
*kcontrol
,
695 struct snd_ctl_elem_value
*ucontrol
)
697 struct snd_soc_component
*component
= snd_soc_kcontrol_component(kcontrol
);
698 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
699 struct wm_adsp
*dsp
= snd_soc_component_get_drvdata(component
);
702 if (ucontrol
->value
.enumerated
.item
[0] == dsp
[e
->shift_l
].fw
)
705 if (ucontrol
->value
.enumerated
.item
[0] >= WM_ADSP_NUM_FW
)
708 mutex_lock(&dsp
[e
->shift_l
].pwr_lock
);
710 if (dsp
[e
->shift_l
].booted
|| dsp
[e
->shift_l
].compr
)
713 dsp
[e
->shift_l
].fw
= ucontrol
->value
.enumerated
.item
[0];
715 mutex_unlock(&dsp
[e
->shift_l
].pwr_lock
);
719 EXPORT_SYMBOL_GPL(wm_adsp_fw_put
);
721 const struct soc_enum wm_adsp_fw_enum
[] = {
722 SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
723 SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
724 SOC_ENUM_SINGLE(0, 2, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
725 SOC_ENUM_SINGLE(0, 3, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
726 SOC_ENUM_SINGLE(0, 4, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
727 SOC_ENUM_SINGLE(0, 5, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
728 SOC_ENUM_SINGLE(0, 6, ARRAY_SIZE(wm_adsp_fw_text
), wm_adsp_fw_text
),
730 EXPORT_SYMBOL_GPL(wm_adsp_fw_enum
);
732 static struct wm_adsp_region
const *wm_adsp_find_region(struct wm_adsp
*dsp
,
737 for (i
= 0; i
< dsp
->num_mems
; i
++)
738 if (dsp
->mem
[i
].type
== type
)
744 static unsigned int wm_adsp_region_to_reg(struct wm_adsp_region
const *mem
,
751 return mem
->base
+ (offset
* 3);
753 return mem
->base
+ (offset
* 2);
755 return mem
->base
+ (offset
* 2);
757 return mem
->base
+ (offset
* 2);
759 return mem
->base
+ (offset
* 2);
761 WARN(1, "Unknown memory region type");
766 static void wm_adsp2_show_fw_status(struct wm_adsp
*dsp
)
771 ret
= regmap_raw_read(dsp
->regmap
, dsp
->base
+ ADSP2_SCRATCH0
,
772 scratch
, sizeof(scratch
));
774 adsp_err(dsp
, "Failed to read SCRATCH regs: %d\n", ret
);
778 adsp_dbg(dsp
, "FW SCRATCH 0:0x%x 1:0x%x 2:0x%x 3:0x%x\n",
779 be16_to_cpu(scratch
[0]),
780 be16_to_cpu(scratch
[1]),
781 be16_to_cpu(scratch
[2]),
782 be16_to_cpu(scratch
[3]));
785 static void wm_adsp2v2_show_fw_status(struct wm_adsp
*dsp
)
790 ret
= regmap_raw_read(dsp
->regmap
, dsp
->base
+ ADSP2V2_SCRATCH0_1
,
791 scratch
, sizeof(scratch
));
794 adsp_err(dsp
, "Failed to read SCRATCH regs: %d\n", ret
);
798 scratch
[0] = be32_to_cpu(scratch
[0]);
799 scratch
[1] = be32_to_cpu(scratch
[1]);
801 adsp_dbg(dsp
, "FW SCRATCH 0:0x%x 1:0x%x 2:0x%x 3:0x%x\n",
808 static inline struct wm_coeff_ctl
*bytes_ext_to_ctl(struct soc_bytes_ext
*ext
)
810 return container_of(ext
, struct wm_coeff_ctl
, bytes_ext
);
813 static int wm_coeff_base_reg(struct wm_coeff_ctl
*ctl
, unsigned int *reg
)
815 const struct wm_adsp_alg_region
*alg_region
= &ctl
->alg_region
;
816 struct wm_adsp
*dsp
= ctl
->dsp
;
817 const struct wm_adsp_region
*mem
;
819 mem
= wm_adsp_find_region(dsp
, alg_region
->type
);
821 adsp_err(dsp
, "No base for region %x\n",
826 *reg
= wm_adsp_region_to_reg(mem
, ctl
->alg_region
.base
+ ctl
->offset
);
831 static int wm_coeff_info(struct snd_kcontrol
*kctl
,
832 struct snd_ctl_elem_info
*uinfo
)
834 struct soc_bytes_ext
*bytes_ext
=
835 (struct soc_bytes_ext
*)kctl
->private_value
;
836 struct wm_coeff_ctl
*ctl
= bytes_ext_to_ctl(bytes_ext
);
839 case WMFW_CTL_TYPE_ACKED
:
840 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
841 uinfo
->value
.integer
.min
= WM_ADSP_ACKED_CTL_MIN_VALUE
;
842 uinfo
->value
.integer
.max
= WM_ADSP_ACKED_CTL_MAX_VALUE
;
843 uinfo
->value
.integer
.step
= 1;
847 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
848 uinfo
->count
= ctl
->len
;
855 static int wm_coeff_write_acked_control(struct wm_coeff_ctl
*ctl
,
856 unsigned int event_id
)
858 struct wm_adsp
*dsp
= ctl
->dsp
;
859 u32 val
= cpu_to_be32(event_id
);
863 ret
= wm_coeff_base_reg(ctl
, ®
);
867 adsp_dbg(dsp
, "Sending 0x%x to acked control alg 0x%x %s:0x%x\n",
868 event_id
, ctl
->alg_region
.alg
,
869 wm_adsp_mem_region_name(ctl
->alg_region
.type
), ctl
->offset
);
871 ret
= regmap_raw_write(dsp
->regmap
, reg
, &val
, sizeof(val
));
873 adsp_err(dsp
, "Failed to write %x: %d\n", reg
, ret
);
878 * Poll for ack, we initially poll at ~1ms intervals for firmwares
879 * that respond quickly, then go to ~10ms polls. A firmware is unlikely
880 * to ack instantly so we do the first 1ms delay before reading the
881 * control to avoid a pointless bus transaction
883 for (i
= 0; i
< WM_ADSP_ACKED_CTL_TIMEOUT_MS
;) {
885 case 0 ... WM_ADSP_ACKED_CTL_N_QUICKPOLLS
- 1:
886 usleep_range(1000, 2000);
890 usleep_range(10000, 20000);
895 ret
= regmap_raw_read(dsp
->regmap
, reg
, &val
, sizeof(val
));
897 adsp_err(dsp
, "Failed to read %x: %d\n", reg
, ret
);
902 adsp_dbg(dsp
, "Acked control ACKED at poll %u\n", i
);
907 adsp_warn(dsp
, "Acked control @0x%x alg:0x%x %s:0x%x timed out\n",
908 reg
, ctl
->alg_region
.alg
,
909 wm_adsp_mem_region_name(ctl
->alg_region
.type
),
915 static int wm_coeff_write_control(struct wm_coeff_ctl
*ctl
,
916 const void *buf
, size_t len
)
918 struct wm_adsp
*dsp
= ctl
->dsp
;
923 ret
= wm_coeff_base_reg(ctl
, ®
);
927 scratch
= kmemdup(buf
, len
, GFP_KERNEL
| GFP_DMA
);
931 ret
= regmap_raw_write(dsp
->regmap
, reg
, scratch
,
934 adsp_err(dsp
, "Failed to write %zu bytes to %x: %d\n",
939 adsp_dbg(dsp
, "Wrote %zu bytes to %x\n", len
, reg
);
946 static int wm_coeff_put(struct snd_kcontrol
*kctl
,
947 struct snd_ctl_elem_value
*ucontrol
)
949 struct soc_bytes_ext
*bytes_ext
=
950 (struct soc_bytes_ext
*)kctl
->private_value
;
951 struct wm_coeff_ctl
*ctl
= bytes_ext_to_ctl(bytes_ext
);
952 char *p
= ucontrol
->value
.bytes
.data
;
955 mutex_lock(&ctl
->dsp
->pwr_lock
);
957 if (ctl
->flags
& WMFW_CTL_FLAG_VOLATILE
)
960 memcpy(ctl
->cache
, p
, ctl
->len
);
963 if (ctl
->enabled
&& ctl
->dsp
->running
)
964 ret
= wm_coeff_write_control(ctl
, p
, ctl
->len
);
966 mutex_unlock(&ctl
->dsp
->pwr_lock
);
971 static int wm_coeff_tlv_put(struct snd_kcontrol
*kctl
,
972 const unsigned int __user
*bytes
, unsigned int size
)
974 struct soc_bytes_ext
*bytes_ext
=
975 (struct soc_bytes_ext
*)kctl
->private_value
;
976 struct wm_coeff_ctl
*ctl
= bytes_ext_to_ctl(bytes_ext
);
979 mutex_lock(&ctl
->dsp
->pwr_lock
);
981 if (copy_from_user(ctl
->cache
, bytes
, size
)) {
985 if (ctl
->enabled
&& ctl
->dsp
->running
)
986 ret
= wm_coeff_write_control(ctl
, ctl
->cache
, size
);
987 else if (ctl
->flags
& WMFW_CTL_FLAG_VOLATILE
)
991 mutex_unlock(&ctl
->dsp
->pwr_lock
);
996 static int wm_coeff_put_acked(struct snd_kcontrol
*kctl
,
997 struct snd_ctl_elem_value
*ucontrol
)
999 struct soc_bytes_ext
*bytes_ext
=
1000 (struct soc_bytes_ext
*)kctl
->private_value
;
1001 struct wm_coeff_ctl
*ctl
= bytes_ext_to_ctl(bytes_ext
);
1002 unsigned int val
= ucontrol
->value
.integer
.value
[0];
1006 return 0; /* 0 means no event */
1008 mutex_lock(&ctl
->dsp
->pwr_lock
);
1010 if (ctl
->enabled
&& ctl
->dsp
->running
)
1011 ret
= wm_coeff_write_acked_control(ctl
, val
);
1015 mutex_unlock(&ctl
->dsp
->pwr_lock
);
1020 static int wm_coeff_read_control(struct wm_coeff_ctl
*ctl
,
1021 void *buf
, size_t len
)
1023 struct wm_adsp
*dsp
= ctl
->dsp
;
1028 ret
= wm_coeff_base_reg(ctl
, ®
);
1032 scratch
= kmalloc(len
, GFP_KERNEL
| GFP_DMA
);
1036 ret
= regmap_raw_read(dsp
->regmap
, reg
, scratch
, len
);
1038 adsp_err(dsp
, "Failed to read %zu bytes from %x: %d\n",
1043 adsp_dbg(dsp
, "Read %zu bytes from %x\n", len
, reg
);
1045 memcpy(buf
, scratch
, len
);
1051 static int wm_coeff_get(struct snd_kcontrol
*kctl
,
1052 struct snd_ctl_elem_value
*ucontrol
)
1054 struct soc_bytes_ext
*bytes_ext
=
1055 (struct soc_bytes_ext
*)kctl
->private_value
;
1056 struct wm_coeff_ctl
*ctl
= bytes_ext_to_ctl(bytes_ext
);
1057 char *p
= ucontrol
->value
.bytes
.data
;
1060 mutex_lock(&ctl
->dsp
->pwr_lock
);
1062 if (ctl
->flags
& WMFW_CTL_FLAG_VOLATILE
) {
1063 if (ctl
->enabled
&& ctl
->dsp
->running
)
1064 ret
= wm_coeff_read_control(ctl
, p
, ctl
->len
);
1068 if (!ctl
->flags
&& ctl
->enabled
&& ctl
->dsp
->running
)
1069 ret
= wm_coeff_read_control(ctl
, ctl
->cache
, ctl
->len
);
1071 memcpy(p
, ctl
->cache
, ctl
->len
);
1074 mutex_unlock(&ctl
->dsp
->pwr_lock
);
1079 static int wm_coeff_tlv_get(struct snd_kcontrol
*kctl
,
1080 unsigned int __user
*bytes
, unsigned int size
)
1082 struct soc_bytes_ext
*bytes_ext
=
1083 (struct soc_bytes_ext
*)kctl
->private_value
;
1084 struct wm_coeff_ctl
*ctl
= bytes_ext_to_ctl(bytes_ext
);
1087 mutex_lock(&ctl
->dsp
->pwr_lock
);
1089 if (ctl
->flags
& WMFW_CTL_FLAG_VOLATILE
) {
1090 if (ctl
->enabled
&& ctl
->dsp
->running
)
1091 ret
= wm_coeff_read_control(ctl
, ctl
->cache
, size
);
1095 if (!ctl
->flags
&& ctl
->enabled
&& ctl
->dsp
->running
)
1096 ret
= wm_coeff_read_control(ctl
, ctl
->cache
, size
);
1099 if (!ret
&& copy_to_user(bytes
, ctl
->cache
, size
))
1102 mutex_unlock(&ctl
->dsp
->pwr_lock
);
1107 static int wm_coeff_get_acked(struct snd_kcontrol
*kcontrol
,
1108 struct snd_ctl_elem_value
*ucontrol
)
1111 * Although it's not useful to read an acked control, we must satisfy
1112 * user-side assumptions that all controls are readable and that a
1113 * write of the same value should be filtered out (it's valid to send
1114 * the same event number again to the firmware). We therefore return 0,
1115 * meaning "no event" so valid event numbers will always be a change
1117 ucontrol
->value
.integer
.value
[0] = 0;
1122 struct wmfw_ctl_work
{
1123 struct wm_adsp
*dsp
;
1124 struct wm_coeff_ctl
*ctl
;
1125 struct work_struct work
;
1128 static unsigned int wmfw_convert_flags(unsigned int in
, unsigned int len
)
1130 unsigned int out
, rd
, wr
, vol
;
1132 if (len
> ADSP_MAX_STD_CTRL_SIZE
) {
1133 rd
= SNDRV_CTL_ELEM_ACCESS_TLV_READ
;
1134 wr
= SNDRV_CTL_ELEM_ACCESS_TLV_WRITE
;
1135 vol
= SNDRV_CTL_ELEM_ACCESS_VOLATILE
;
1137 out
= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
;
1139 rd
= SNDRV_CTL_ELEM_ACCESS_READ
;
1140 wr
= SNDRV_CTL_ELEM_ACCESS_WRITE
;
1141 vol
= SNDRV_CTL_ELEM_ACCESS_VOLATILE
;
1147 if (in
& WMFW_CTL_FLAG_READABLE
)
1149 if (in
& WMFW_CTL_FLAG_WRITEABLE
)
1151 if (in
& WMFW_CTL_FLAG_VOLATILE
)
1154 out
|= rd
| wr
| vol
;
1160 static int wmfw_add_ctl(struct wm_adsp
*dsp
, struct wm_coeff_ctl
*ctl
)
1162 struct snd_kcontrol_new
*kcontrol
;
1165 if (!ctl
|| !ctl
->name
)
1168 kcontrol
= kzalloc(sizeof(*kcontrol
), GFP_KERNEL
);
1172 kcontrol
->name
= ctl
->name
;
1173 kcontrol
->info
= wm_coeff_info
;
1174 kcontrol
->iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1175 kcontrol
->tlv
.c
= snd_soc_bytes_tlv_callback
;
1176 kcontrol
->private_value
= (unsigned long)&ctl
->bytes_ext
;
1177 kcontrol
->access
= wmfw_convert_flags(ctl
->flags
, ctl
->len
);
1179 switch (ctl
->type
) {
1180 case WMFW_CTL_TYPE_ACKED
:
1181 kcontrol
->get
= wm_coeff_get_acked
;
1182 kcontrol
->put
= wm_coeff_put_acked
;
1185 if (kcontrol
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
) {
1186 ctl
->bytes_ext
.max
= ctl
->len
;
1187 ctl
->bytes_ext
.get
= wm_coeff_tlv_get
;
1188 ctl
->bytes_ext
.put
= wm_coeff_tlv_put
;
1190 kcontrol
->get
= wm_coeff_get
;
1191 kcontrol
->put
= wm_coeff_put
;
1196 ret
= snd_soc_add_component_controls(dsp
->component
, kcontrol
, 1);
1209 static int wm_coeff_init_control_caches(struct wm_adsp
*dsp
)
1211 struct wm_coeff_ctl
*ctl
;
1214 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
) {
1215 if (!ctl
->enabled
|| ctl
->set
)
1217 if (ctl
->flags
& WMFW_CTL_FLAG_VOLATILE
)
1221 * For readable controls populate the cache from the DSP memory.
1222 * For non-readable controls the cache was zero-filled when
1223 * created so we don't need to do anything.
1225 if (!ctl
->flags
|| (ctl
->flags
& WMFW_CTL_FLAG_READABLE
)) {
1226 ret
= wm_coeff_read_control(ctl
, ctl
->cache
, ctl
->len
);
1235 static int wm_coeff_sync_controls(struct wm_adsp
*dsp
)
1237 struct wm_coeff_ctl
*ctl
;
1240 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
) {
1243 if (ctl
->set
&& !(ctl
->flags
& WMFW_CTL_FLAG_VOLATILE
)) {
1244 ret
= wm_coeff_write_control(ctl
, ctl
->cache
, ctl
->len
);
1253 static void wm_adsp_signal_event_controls(struct wm_adsp
*dsp
,
1256 struct wm_coeff_ctl
*ctl
;
1259 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
) {
1260 if (ctl
->type
!= WMFW_CTL_TYPE_HOSTEVENT
)
1266 ret
= wm_coeff_write_acked_control(ctl
, event
);
1269 "Failed to send 0x%x event to alg 0x%x (%d)\n",
1270 event
, ctl
->alg_region
.alg
, ret
);
1274 static void wm_adsp_ctl_work(struct work_struct
*work
)
1276 struct wmfw_ctl_work
*ctl_work
= container_of(work
,
1277 struct wmfw_ctl_work
,
1280 wmfw_add_ctl(ctl_work
->dsp
, ctl_work
->ctl
);
1284 static void wm_adsp_free_ctl_blk(struct wm_coeff_ctl
*ctl
)
1291 static int wm_adsp_create_control(struct wm_adsp
*dsp
,
1292 const struct wm_adsp_alg_region
*alg_region
,
1293 unsigned int offset
, unsigned int len
,
1294 const char *subname
, unsigned int subname_len
,
1295 unsigned int flags
, unsigned int type
)
1297 struct wm_coeff_ctl
*ctl
;
1298 struct wmfw_ctl_work
*ctl_work
;
1299 char name
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
1300 const char *region_name
;
1303 region_name
= wm_adsp_mem_region_name(alg_region
->type
);
1305 adsp_err(dsp
, "Unknown region type: %d\n", alg_region
->type
);
1309 switch (dsp
->fw_ver
) {
1312 snprintf(name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
, "%s %s %x",
1313 dsp
->name
, region_name
, alg_region
->alg
);
1316 ret
= snprintf(name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
,
1317 "%s%c %.12s %x", dsp
->name
, *region_name
,
1318 wm_adsp_fw_text
[dsp
->fw
], alg_region
->alg
);
1320 /* Truncate the subname from the start if it is too long */
1322 int avail
= SNDRV_CTL_ELEM_ID_NAME_MAXLEN
- ret
- 2;
1325 if (dsp
->component
->name_prefix
)
1326 avail
-= strlen(dsp
->component
->name_prefix
) + 1;
1328 if (subname_len
> avail
)
1329 skip
= subname_len
- avail
;
1331 snprintf(name
+ ret
,
1332 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
- ret
, " %.*s",
1333 subname_len
- skip
, subname
+ skip
);
1338 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
) {
1339 if (!strcmp(ctl
->name
, name
)) {
1346 ctl
= kzalloc(sizeof(*ctl
), GFP_KERNEL
);
1349 ctl
->fw_name
= wm_adsp_fw_text
[dsp
->fw
];
1350 ctl
->alg_region
= *alg_region
;
1351 ctl
->name
= kmemdup(name
, strlen(name
) + 1, GFP_KERNEL
);
1358 ctl
->ops
.xget
= wm_coeff_get
;
1359 ctl
->ops
.xput
= wm_coeff_put
;
1364 ctl
->offset
= offset
;
1366 ctl
->cache
= kzalloc(ctl
->len
, GFP_KERNEL
);
1372 list_add(&ctl
->list
, &dsp
->ctl_list
);
1374 if (flags
& WMFW_CTL_FLAG_SYS
)
1377 ctl_work
= kzalloc(sizeof(*ctl_work
), GFP_KERNEL
);
1383 ctl_work
->dsp
= dsp
;
1384 ctl_work
->ctl
= ctl
;
1385 INIT_WORK(&ctl_work
->work
, wm_adsp_ctl_work
);
1386 schedule_work(&ctl_work
->work
);
1400 struct wm_coeff_parsed_alg
{
1407 struct wm_coeff_parsed_coeff
{
1417 static int wm_coeff_parse_string(int bytes
, const u8
**pos
, const u8
**str
)
1426 length
= le16_to_cpu(*((__le16
*)*pos
));
1433 *str
= *pos
+ bytes
;
1435 *pos
+= ((length
+ bytes
) + 3) & ~0x03;
1440 static int wm_coeff_parse_int(int bytes
, const u8
**pos
)
1446 val
= le16_to_cpu(*((__le16
*)*pos
));
1449 val
= le32_to_cpu(*((__le32
*)*pos
));
1460 static inline void wm_coeff_parse_alg(struct wm_adsp
*dsp
, const u8
**data
,
1461 struct wm_coeff_parsed_alg
*blk
)
1463 const struct wmfw_adsp_alg_data
*raw
;
1465 switch (dsp
->fw_ver
) {
1468 raw
= (const struct wmfw_adsp_alg_data
*)*data
;
1471 blk
->id
= le32_to_cpu(raw
->id
);
1472 blk
->name
= raw
->name
;
1473 blk
->name_len
= strlen(raw
->name
);
1474 blk
->ncoeff
= le32_to_cpu(raw
->ncoeff
);
1477 blk
->id
= wm_coeff_parse_int(sizeof(raw
->id
), data
);
1478 blk
->name_len
= wm_coeff_parse_string(sizeof(u8
), data
,
1480 wm_coeff_parse_string(sizeof(u16
), data
, NULL
);
1481 blk
->ncoeff
= wm_coeff_parse_int(sizeof(raw
->ncoeff
), data
);
1485 adsp_dbg(dsp
, "Algorithm ID: %#x\n", blk
->id
);
1486 adsp_dbg(dsp
, "Algorithm name: %.*s\n", blk
->name_len
, blk
->name
);
1487 adsp_dbg(dsp
, "# of coefficient descriptors: %#x\n", blk
->ncoeff
);
1490 static inline void wm_coeff_parse_coeff(struct wm_adsp
*dsp
, const u8
**data
,
1491 struct wm_coeff_parsed_coeff
*blk
)
1493 const struct wmfw_adsp_coeff_data
*raw
;
1497 switch (dsp
->fw_ver
) {
1500 raw
= (const struct wmfw_adsp_coeff_data
*)*data
;
1501 *data
= *data
+ sizeof(raw
->hdr
) + le32_to_cpu(raw
->hdr
.size
);
1503 blk
->offset
= le16_to_cpu(raw
->hdr
.offset
);
1504 blk
->mem_type
= le16_to_cpu(raw
->hdr
.type
);
1505 blk
->name
= raw
->name
;
1506 blk
->name_len
= strlen(raw
->name
);
1507 blk
->ctl_type
= le16_to_cpu(raw
->ctl_type
);
1508 blk
->flags
= le16_to_cpu(raw
->flags
);
1509 blk
->len
= le32_to_cpu(raw
->len
);
1513 blk
->offset
= wm_coeff_parse_int(sizeof(raw
->hdr
.offset
), &tmp
);
1514 blk
->mem_type
= wm_coeff_parse_int(sizeof(raw
->hdr
.type
), &tmp
);
1515 length
= wm_coeff_parse_int(sizeof(raw
->hdr
.size
), &tmp
);
1516 blk
->name_len
= wm_coeff_parse_string(sizeof(u8
), &tmp
,
1518 wm_coeff_parse_string(sizeof(u8
), &tmp
, NULL
);
1519 wm_coeff_parse_string(sizeof(u16
), &tmp
, NULL
);
1520 blk
->ctl_type
= wm_coeff_parse_int(sizeof(raw
->ctl_type
), &tmp
);
1521 blk
->flags
= wm_coeff_parse_int(sizeof(raw
->flags
), &tmp
);
1522 blk
->len
= wm_coeff_parse_int(sizeof(raw
->len
), &tmp
);
1524 *data
= *data
+ sizeof(raw
->hdr
) + length
;
1528 adsp_dbg(dsp
, "\tCoefficient type: %#x\n", blk
->mem_type
);
1529 adsp_dbg(dsp
, "\tCoefficient offset: %#x\n", blk
->offset
);
1530 adsp_dbg(dsp
, "\tCoefficient name: %.*s\n", blk
->name_len
, blk
->name
);
1531 adsp_dbg(dsp
, "\tCoefficient flags: %#x\n", blk
->flags
);
1532 adsp_dbg(dsp
, "\tALSA control type: %#x\n", blk
->ctl_type
);
1533 adsp_dbg(dsp
, "\tALSA control len: %#x\n", blk
->len
);
1536 static int wm_adsp_check_coeff_flags(struct wm_adsp
*dsp
,
1537 const struct wm_coeff_parsed_coeff
*coeff_blk
,
1538 unsigned int f_required
,
1539 unsigned int f_illegal
)
1541 if ((coeff_blk
->flags
& f_illegal
) ||
1542 ((coeff_blk
->flags
& f_required
) != f_required
)) {
1543 adsp_err(dsp
, "Illegal flags 0x%x for control type 0x%x\n",
1544 coeff_blk
->flags
, coeff_blk
->ctl_type
);
1551 static int wm_adsp_parse_coeff(struct wm_adsp
*dsp
,
1552 const struct wmfw_region
*region
)
1554 struct wm_adsp_alg_region alg_region
= {};
1555 struct wm_coeff_parsed_alg alg_blk
;
1556 struct wm_coeff_parsed_coeff coeff_blk
;
1557 const u8
*data
= region
->data
;
1560 wm_coeff_parse_alg(dsp
, &data
, &alg_blk
);
1561 for (i
= 0; i
< alg_blk
.ncoeff
; i
++) {
1562 wm_coeff_parse_coeff(dsp
, &data
, &coeff_blk
);
1564 switch (coeff_blk
.ctl_type
) {
1565 case SNDRV_CTL_ELEM_TYPE_BYTES
:
1567 case WMFW_CTL_TYPE_ACKED
:
1568 if (coeff_blk
.flags
& WMFW_CTL_FLAG_SYS
)
1569 continue; /* ignore */
1571 ret
= wm_adsp_check_coeff_flags(dsp
, &coeff_blk
,
1572 WMFW_CTL_FLAG_VOLATILE
|
1573 WMFW_CTL_FLAG_WRITEABLE
|
1574 WMFW_CTL_FLAG_READABLE
,
1579 case WMFW_CTL_TYPE_HOSTEVENT
:
1580 ret
= wm_adsp_check_coeff_flags(dsp
, &coeff_blk
,
1582 WMFW_CTL_FLAG_VOLATILE
|
1583 WMFW_CTL_FLAG_WRITEABLE
|
1584 WMFW_CTL_FLAG_READABLE
,
1589 case WMFW_CTL_TYPE_HOST_BUFFER
:
1590 ret
= wm_adsp_check_coeff_flags(dsp
, &coeff_blk
,
1592 WMFW_CTL_FLAG_VOLATILE
|
1593 WMFW_CTL_FLAG_READABLE
,
1599 adsp_err(dsp
, "Unknown control type: %d\n",
1600 coeff_blk
.ctl_type
);
1604 alg_region
.type
= coeff_blk
.mem_type
;
1605 alg_region
.alg
= alg_blk
.id
;
1607 ret
= wm_adsp_create_control(dsp
, &alg_region
,
1613 coeff_blk
.ctl_type
);
1615 adsp_err(dsp
, "Failed to create control: %.*s, %d\n",
1616 coeff_blk
.name_len
, coeff_blk
.name
, ret
);
1622 static int wm_adsp_load(struct wm_adsp
*dsp
)
1624 LIST_HEAD(buf_list
);
1625 const struct firmware
*firmware
;
1626 struct regmap
*regmap
= dsp
->regmap
;
1627 unsigned int pos
= 0;
1628 const struct wmfw_header
*header
;
1629 const struct wmfw_adsp1_sizes
*adsp1_sizes
;
1630 const struct wmfw_adsp2_sizes
*adsp2_sizes
;
1631 const struct wmfw_footer
*footer
;
1632 const struct wmfw_region
*region
;
1633 const struct wm_adsp_region
*mem
;
1634 const char *region_name
;
1635 char *file
, *text
= NULL
;
1636 struct wm_adsp_buf
*buf
;
1639 int ret
, offset
, type
, sizes
;
1641 file
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
1645 snprintf(file
, PAGE_SIZE
, "%s-%s-%s.wmfw", dsp
->part
, dsp
->fwf_name
,
1646 wm_adsp_fw
[dsp
->fw
].file
);
1647 file
[PAGE_SIZE
- 1] = '\0';
1649 ret
= request_firmware(&firmware
, file
, dsp
->dev
);
1651 adsp_err(dsp
, "Failed to request '%s'\n", file
);
1656 pos
= sizeof(*header
) + sizeof(*adsp1_sizes
) + sizeof(*footer
);
1657 if (pos
>= firmware
->size
) {
1658 adsp_err(dsp
, "%s: file too short, %zu bytes\n",
1659 file
, firmware
->size
);
1663 header
= (void *)&firmware
->data
[0];
1665 if (memcmp(&header
->magic
[0], "WMFW", 4) != 0) {
1666 adsp_err(dsp
, "%s: invalid magic\n", file
);
1670 switch (header
->ver
) {
1672 adsp_warn(dsp
, "%s: Depreciated file format %d\n",
1679 adsp_err(dsp
, "%s: unknown file format %d\n",
1684 adsp_info(dsp
, "Firmware version: %d\n", header
->ver
);
1685 dsp
->fw_ver
= header
->ver
;
1687 if (header
->core
!= dsp
->type
) {
1688 adsp_err(dsp
, "%s: invalid core %d != %d\n",
1689 file
, header
->core
, dsp
->type
);
1693 switch (dsp
->type
) {
1695 pos
= sizeof(*header
) + sizeof(*adsp1_sizes
) + sizeof(*footer
);
1696 adsp1_sizes
= (void *)&(header
[1]);
1697 footer
= (void *)&(adsp1_sizes
[1]);
1698 sizes
= sizeof(*adsp1_sizes
);
1700 adsp_dbg(dsp
, "%s: %d DM, %d PM, %d ZM\n",
1701 file
, le32_to_cpu(adsp1_sizes
->dm
),
1702 le32_to_cpu(adsp1_sizes
->pm
),
1703 le32_to_cpu(adsp1_sizes
->zm
));
1707 pos
= sizeof(*header
) + sizeof(*adsp2_sizes
) + sizeof(*footer
);
1708 adsp2_sizes
= (void *)&(header
[1]);
1709 footer
= (void *)&(adsp2_sizes
[1]);
1710 sizes
= sizeof(*adsp2_sizes
);
1712 adsp_dbg(dsp
, "%s: %d XM, %d YM %d PM, %d ZM\n",
1713 file
, le32_to_cpu(adsp2_sizes
->xm
),
1714 le32_to_cpu(adsp2_sizes
->ym
),
1715 le32_to_cpu(adsp2_sizes
->pm
),
1716 le32_to_cpu(adsp2_sizes
->zm
));
1720 WARN(1, "Unknown DSP type");
1724 if (le32_to_cpu(header
->len
) != sizeof(*header
) +
1725 sizes
+ sizeof(*footer
)) {
1726 adsp_err(dsp
, "%s: unexpected header length %d\n",
1727 file
, le32_to_cpu(header
->len
));
1731 adsp_dbg(dsp
, "%s: timestamp %llu\n", file
,
1732 le64_to_cpu(footer
->timestamp
));
1734 while (pos
< firmware
->size
&&
1735 sizeof(*region
) < firmware
->size
- pos
) {
1736 region
= (void *)&(firmware
->data
[pos
]);
1737 region_name
= "Unknown";
1740 offset
= le32_to_cpu(region
->offset
) & 0xffffff;
1741 type
= be32_to_cpu(region
->type
) & 0xff;
1742 mem
= wm_adsp_find_region(dsp
, type
);
1745 case WMFW_NAME_TEXT
:
1746 region_name
= "Firmware name";
1747 text
= kzalloc(le32_to_cpu(region
->len
) + 1,
1750 case WMFW_ALGORITHM_DATA
:
1751 region_name
= "Algorithm";
1752 ret
= wm_adsp_parse_coeff(dsp
, region
);
1756 case WMFW_INFO_TEXT
:
1757 region_name
= "Information";
1758 text
= kzalloc(le32_to_cpu(region
->len
) + 1,
1762 region_name
= "Absolute";
1770 region_name
= wm_adsp_mem_region_name(type
);
1771 reg
= wm_adsp_region_to_reg(mem
, offset
);
1775 "%s.%d: Unknown region type %x at %d(%x)\n",
1776 file
, regions
, type
, pos
, pos
);
1780 adsp_dbg(dsp
, "%s.%d: %d bytes at %d in %s\n", file
,
1781 regions
, le32_to_cpu(region
->len
), offset
,
1784 if (le32_to_cpu(region
->len
) >
1785 firmware
->size
- pos
- sizeof(*region
)) {
1787 "%s.%d: %s region len %d bytes exceeds file length %zu\n",
1788 file
, regions
, region_name
,
1789 le32_to_cpu(region
->len
), firmware
->size
);
1795 memcpy(text
, region
->data
, le32_to_cpu(region
->len
));
1796 adsp_info(dsp
, "%s: %s\n", file
, text
);
1802 buf
= wm_adsp_buf_alloc(region
->data
,
1803 le32_to_cpu(region
->len
),
1806 adsp_err(dsp
, "Out of memory\n");
1811 ret
= regmap_raw_write_async(regmap
, reg
, buf
->buf
,
1812 le32_to_cpu(region
->len
));
1815 "%s.%d: Failed to write %d bytes at %d in %s: %d\n",
1817 le32_to_cpu(region
->len
), offset
,
1823 pos
+= le32_to_cpu(region
->len
) + sizeof(*region
);
1827 ret
= regmap_async_complete(regmap
);
1829 adsp_err(dsp
, "Failed to complete async write: %d\n", ret
);
1833 if (pos
> firmware
->size
)
1834 adsp_warn(dsp
, "%s.%d: %zu bytes at end of file\n",
1835 file
, regions
, pos
- firmware
->size
);
1837 wm_adsp_debugfs_save_wmfwname(dsp
, file
);
1840 regmap_async_complete(regmap
);
1841 wm_adsp_buf_free(&buf_list
);
1842 release_firmware(firmware
);
1850 static void wm_adsp_ctl_fixup_base(struct wm_adsp
*dsp
,
1851 const struct wm_adsp_alg_region
*alg_region
)
1853 struct wm_coeff_ctl
*ctl
;
1855 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
) {
1856 if (ctl
->fw_name
== wm_adsp_fw_text
[dsp
->fw
] &&
1857 alg_region
->alg
== ctl
->alg_region
.alg
&&
1858 alg_region
->type
== ctl
->alg_region
.type
) {
1859 ctl
->alg_region
.base
= alg_region
->base
;
1864 static void *wm_adsp_read_algs(struct wm_adsp
*dsp
, size_t n_algs
,
1865 const struct wm_adsp_region
*mem
,
1866 unsigned int pos
, unsigned int len
)
1874 adsp_err(dsp
, "No algorithms\n");
1875 return ERR_PTR(-EINVAL
);
1878 if (n_algs
> 1024) {
1879 adsp_err(dsp
, "Algorithm count %zx excessive\n", n_algs
);
1880 return ERR_PTR(-EINVAL
);
1883 /* Read the terminator first to validate the length */
1884 reg
= wm_adsp_region_to_reg(mem
, pos
+ len
);
1886 ret
= regmap_raw_read(dsp
->regmap
, reg
, &val
, sizeof(val
));
1888 adsp_err(dsp
, "Failed to read algorithm list end: %d\n",
1890 return ERR_PTR(ret
);
1893 if (be32_to_cpu(val
) != 0xbedead)
1894 adsp_warn(dsp
, "Algorithm list end %x 0x%x != 0xbedead\n",
1895 reg
, be32_to_cpu(val
));
1897 /* Convert length from DSP words to bytes */
1900 alg
= kzalloc(len
, GFP_KERNEL
| GFP_DMA
);
1902 return ERR_PTR(-ENOMEM
);
1904 reg
= wm_adsp_region_to_reg(mem
, pos
);
1906 ret
= regmap_raw_read(dsp
->regmap
, reg
, alg
, len
);
1908 adsp_err(dsp
, "Failed to read algorithm list: %d\n", ret
);
1910 return ERR_PTR(ret
);
1916 static struct wm_adsp_alg_region
*
1917 wm_adsp_find_alg_region(struct wm_adsp
*dsp
, int type
, unsigned int id
)
1919 struct wm_adsp_alg_region
*alg_region
;
1921 list_for_each_entry(alg_region
, &dsp
->alg_regions
, list
) {
1922 if (id
== alg_region
->alg
&& type
== alg_region
->type
)
1929 static struct wm_adsp_alg_region
*wm_adsp_create_region(struct wm_adsp
*dsp
,
1930 int type
, __be32 id
,
1933 struct wm_adsp_alg_region
*alg_region
;
1935 alg_region
= kzalloc(sizeof(*alg_region
), GFP_KERNEL
);
1937 return ERR_PTR(-ENOMEM
);
1939 alg_region
->type
= type
;
1940 alg_region
->alg
= be32_to_cpu(id
);
1941 alg_region
->base
= be32_to_cpu(base
);
1943 list_add_tail(&alg_region
->list
, &dsp
->alg_regions
);
1945 if (dsp
->fw_ver
> 0)
1946 wm_adsp_ctl_fixup_base(dsp
, alg_region
);
1951 static void wm_adsp_free_alg_regions(struct wm_adsp
*dsp
)
1953 struct wm_adsp_alg_region
*alg_region
;
1955 while (!list_empty(&dsp
->alg_regions
)) {
1956 alg_region
= list_first_entry(&dsp
->alg_regions
,
1957 struct wm_adsp_alg_region
,
1959 list_del(&alg_region
->list
);
1964 static int wm_adsp1_setup_algs(struct wm_adsp
*dsp
)
1966 struct wmfw_adsp1_id_hdr adsp1_id
;
1967 struct wmfw_adsp1_alg_hdr
*adsp1_alg
;
1968 struct wm_adsp_alg_region
*alg_region
;
1969 const struct wm_adsp_region
*mem
;
1970 unsigned int pos
, len
;
1974 mem
= wm_adsp_find_region(dsp
, WMFW_ADSP1_DM
);
1978 ret
= regmap_raw_read(dsp
->regmap
, mem
->base
, &adsp1_id
,
1981 adsp_err(dsp
, "Failed to read algorithm info: %d\n",
1986 n_algs
= be32_to_cpu(adsp1_id
.n_algs
);
1987 dsp
->fw_id
= be32_to_cpu(adsp1_id
.fw
.id
);
1988 adsp_info(dsp
, "Firmware: %x v%d.%d.%d, %zu algorithms\n",
1990 (be32_to_cpu(adsp1_id
.fw
.ver
) & 0xff0000) >> 16,
1991 (be32_to_cpu(adsp1_id
.fw
.ver
) & 0xff00) >> 8,
1992 be32_to_cpu(adsp1_id
.fw
.ver
) & 0xff,
1995 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP1_ZM
,
1996 adsp1_id
.fw
.id
, adsp1_id
.zm
);
1997 if (IS_ERR(alg_region
))
1998 return PTR_ERR(alg_region
);
2000 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP1_DM
,
2001 adsp1_id
.fw
.id
, adsp1_id
.dm
);
2002 if (IS_ERR(alg_region
))
2003 return PTR_ERR(alg_region
);
2005 /* Calculate offset and length in DSP words */
2006 pos
= sizeof(adsp1_id
) / sizeof(u32
);
2007 len
= (sizeof(*adsp1_alg
) * n_algs
) / sizeof(u32
);
2009 adsp1_alg
= wm_adsp_read_algs(dsp
, n_algs
, mem
, pos
, len
);
2010 if (IS_ERR(adsp1_alg
))
2011 return PTR_ERR(adsp1_alg
);
2013 for (i
= 0; i
< n_algs
; i
++) {
2014 adsp_info(dsp
, "%d: ID %x v%d.%d.%d DM@%x ZM@%x\n",
2015 i
, be32_to_cpu(adsp1_alg
[i
].alg
.id
),
2016 (be32_to_cpu(adsp1_alg
[i
].alg
.ver
) & 0xff0000) >> 16,
2017 (be32_to_cpu(adsp1_alg
[i
].alg
.ver
) & 0xff00) >> 8,
2018 be32_to_cpu(adsp1_alg
[i
].alg
.ver
) & 0xff,
2019 be32_to_cpu(adsp1_alg
[i
].dm
),
2020 be32_to_cpu(adsp1_alg
[i
].zm
));
2022 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP1_DM
,
2023 adsp1_alg
[i
].alg
.id
,
2025 if (IS_ERR(alg_region
)) {
2026 ret
= PTR_ERR(alg_region
);
2029 if (dsp
->fw_ver
== 0) {
2030 if (i
+ 1 < n_algs
) {
2031 len
= be32_to_cpu(adsp1_alg
[i
+ 1].dm
);
2032 len
-= be32_to_cpu(adsp1_alg
[i
].dm
);
2034 wm_adsp_create_control(dsp
, alg_region
, 0,
2036 SNDRV_CTL_ELEM_TYPE_BYTES
);
2038 adsp_warn(dsp
, "Missing length info for region DM with ID %x\n",
2039 be32_to_cpu(adsp1_alg
[i
].alg
.id
));
2043 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP1_ZM
,
2044 adsp1_alg
[i
].alg
.id
,
2046 if (IS_ERR(alg_region
)) {
2047 ret
= PTR_ERR(alg_region
);
2050 if (dsp
->fw_ver
== 0) {
2051 if (i
+ 1 < n_algs
) {
2052 len
= be32_to_cpu(adsp1_alg
[i
+ 1].zm
);
2053 len
-= be32_to_cpu(adsp1_alg
[i
].zm
);
2055 wm_adsp_create_control(dsp
, alg_region
, 0,
2057 SNDRV_CTL_ELEM_TYPE_BYTES
);
2059 adsp_warn(dsp
, "Missing length info for region ZM with ID %x\n",
2060 be32_to_cpu(adsp1_alg
[i
].alg
.id
));
2070 static int wm_adsp2_setup_algs(struct wm_adsp
*dsp
)
2072 struct wmfw_adsp2_id_hdr adsp2_id
;
2073 struct wmfw_adsp2_alg_hdr
*adsp2_alg
;
2074 struct wm_adsp_alg_region
*alg_region
;
2075 const struct wm_adsp_region
*mem
;
2076 unsigned int pos
, len
;
2080 mem
= wm_adsp_find_region(dsp
, WMFW_ADSP2_XM
);
2084 ret
= regmap_raw_read(dsp
->regmap
, mem
->base
, &adsp2_id
,
2087 adsp_err(dsp
, "Failed to read algorithm info: %d\n",
2092 n_algs
= be32_to_cpu(adsp2_id
.n_algs
);
2093 dsp
->fw_id
= be32_to_cpu(adsp2_id
.fw
.id
);
2094 dsp
->fw_id_version
= be32_to_cpu(adsp2_id
.fw
.ver
);
2095 adsp_info(dsp
, "Firmware: %x v%d.%d.%d, %zu algorithms\n",
2097 (dsp
->fw_id_version
& 0xff0000) >> 16,
2098 (dsp
->fw_id_version
& 0xff00) >> 8,
2099 dsp
->fw_id_version
& 0xff,
2102 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP2_XM
,
2103 adsp2_id
.fw
.id
, adsp2_id
.xm
);
2104 if (IS_ERR(alg_region
))
2105 return PTR_ERR(alg_region
);
2107 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP2_YM
,
2108 adsp2_id
.fw
.id
, adsp2_id
.ym
);
2109 if (IS_ERR(alg_region
))
2110 return PTR_ERR(alg_region
);
2112 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP2_ZM
,
2113 adsp2_id
.fw
.id
, adsp2_id
.zm
);
2114 if (IS_ERR(alg_region
))
2115 return PTR_ERR(alg_region
);
2117 /* Calculate offset and length in DSP words */
2118 pos
= sizeof(adsp2_id
) / sizeof(u32
);
2119 len
= (sizeof(*adsp2_alg
) * n_algs
) / sizeof(u32
);
2121 adsp2_alg
= wm_adsp_read_algs(dsp
, n_algs
, mem
, pos
, len
);
2122 if (IS_ERR(adsp2_alg
))
2123 return PTR_ERR(adsp2_alg
);
2125 for (i
= 0; i
< n_algs
; i
++) {
2127 "%d: ID %x v%d.%d.%d XM@%x YM@%x ZM@%x\n",
2128 i
, be32_to_cpu(adsp2_alg
[i
].alg
.id
),
2129 (be32_to_cpu(adsp2_alg
[i
].alg
.ver
) & 0xff0000) >> 16,
2130 (be32_to_cpu(adsp2_alg
[i
].alg
.ver
) & 0xff00) >> 8,
2131 be32_to_cpu(adsp2_alg
[i
].alg
.ver
) & 0xff,
2132 be32_to_cpu(adsp2_alg
[i
].xm
),
2133 be32_to_cpu(adsp2_alg
[i
].ym
),
2134 be32_to_cpu(adsp2_alg
[i
].zm
));
2136 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP2_XM
,
2137 adsp2_alg
[i
].alg
.id
,
2139 if (IS_ERR(alg_region
)) {
2140 ret
= PTR_ERR(alg_region
);
2143 if (dsp
->fw_ver
== 0) {
2144 if (i
+ 1 < n_algs
) {
2145 len
= be32_to_cpu(adsp2_alg
[i
+ 1].xm
);
2146 len
-= be32_to_cpu(adsp2_alg
[i
].xm
);
2148 wm_adsp_create_control(dsp
, alg_region
, 0,
2150 SNDRV_CTL_ELEM_TYPE_BYTES
);
2152 adsp_warn(dsp
, "Missing length info for region XM with ID %x\n",
2153 be32_to_cpu(adsp2_alg
[i
].alg
.id
));
2157 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP2_YM
,
2158 adsp2_alg
[i
].alg
.id
,
2160 if (IS_ERR(alg_region
)) {
2161 ret
= PTR_ERR(alg_region
);
2164 if (dsp
->fw_ver
== 0) {
2165 if (i
+ 1 < n_algs
) {
2166 len
= be32_to_cpu(adsp2_alg
[i
+ 1].ym
);
2167 len
-= be32_to_cpu(adsp2_alg
[i
].ym
);
2169 wm_adsp_create_control(dsp
, alg_region
, 0,
2171 SNDRV_CTL_ELEM_TYPE_BYTES
);
2173 adsp_warn(dsp
, "Missing length info for region YM with ID %x\n",
2174 be32_to_cpu(adsp2_alg
[i
].alg
.id
));
2178 alg_region
= wm_adsp_create_region(dsp
, WMFW_ADSP2_ZM
,
2179 adsp2_alg
[i
].alg
.id
,
2181 if (IS_ERR(alg_region
)) {
2182 ret
= PTR_ERR(alg_region
);
2185 if (dsp
->fw_ver
== 0) {
2186 if (i
+ 1 < n_algs
) {
2187 len
= be32_to_cpu(adsp2_alg
[i
+ 1].zm
);
2188 len
-= be32_to_cpu(adsp2_alg
[i
].zm
);
2190 wm_adsp_create_control(dsp
, alg_region
, 0,
2192 SNDRV_CTL_ELEM_TYPE_BYTES
);
2194 adsp_warn(dsp
, "Missing length info for region ZM with ID %x\n",
2195 be32_to_cpu(adsp2_alg
[i
].alg
.id
));
2205 static int wm_adsp_load_coeff(struct wm_adsp
*dsp
)
2207 LIST_HEAD(buf_list
);
2208 struct regmap
*regmap
= dsp
->regmap
;
2209 struct wmfw_coeff_hdr
*hdr
;
2210 struct wmfw_coeff_item
*blk
;
2211 const struct firmware
*firmware
;
2212 const struct wm_adsp_region
*mem
;
2213 struct wm_adsp_alg_region
*alg_region
;
2214 const char *region_name
;
2215 int ret
, pos
, blocks
, type
, offset
, reg
;
2217 struct wm_adsp_buf
*buf
;
2219 file
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
2223 snprintf(file
, PAGE_SIZE
, "%s-%s-%s.bin", dsp
->part
, dsp
->fwf_name
,
2224 wm_adsp_fw
[dsp
->fw
].file
);
2225 file
[PAGE_SIZE
- 1] = '\0';
2227 ret
= request_firmware(&firmware
, file
, dsp
->dev
);
2229 adsp_warn(dsp
, "Failed to request '%s'\n", file
);
2235 if (sizeof(*hdr
) >= firmware
->size
) {
2236 adsp_err(dsp
, "%s: file too short, %zu bytes\n",
2237 file
, firmware
->size
);
2241 hdr
= (void *)&firmware
->data
[0];
2242 if (memcmp(hdr
->magic
, "WMDR", 4) != 0) {
2243 adsp_err(dsp
, "%s: invalid magic\n", file
);
2247 switch (be32_to_cpu(hdr
->rev
) & 0xff) {
2251 adsp_err(dsp
, "%s: Unsupported coefficient file format %d\n",
2252 file
, be32_to_cpu(hdr
->rev
) & 0xff);
2257 adsp_dbg(dsp
, "%s: v%d.%d.%d\n", file
,
2258 (le32_to_cpu(hdr
->ver
) >> 16) & 0xff,
2259 (le32_to_cpu(hdr
->ver
) >> 8) & 0xff,
2260 le32_to_cpu(hdr
->ver
) & 0xff);
2262 pos
= le32_to_cpu(hdr
->len
);
2265 while (pos
< firmware
->size
&&
2266 sizeof(*blk
) < firmware
->size
- pos
) {
2267 blk
= (void *)(&firmware
->data
[pos
]);
2269 type
= le16_to_cpu(blk
->type
);
2270 offset
= le16_to_cpu(blk
->offset
);
2272 adsp_dbg(dsp
, "%s.%d: %x v%d.%d.%d\n",
2273 file
, blocks
, le32_to_cpu(blk
->id
),
2274 (le32_to_cpu(blk
->ver
) >> 16) & 0xff,
2275 (le32_to_cpu(blk
->ver
) >> 8) & 0xff,
2276 le32_to_cpu(blk
->ver
) & 0xff);
2277 adsp_dbg(dsp
, "%s.%d: %d bytes at 0x%x in %x\n",
2278 file
, blocks
, le32_to_cpu(blk
->len
), offset
, type
);
2281 region_name
= "Unknown";
2283 case (WMFW_NAME_TEXT
<< 8):
2284 case (WMFW_INFO_TEXT
<< 8):
2286 case (WMFW_ABSOLUTE
<< 8):
2288 * Old files may use this for global
2291 if (le32_to_cpu(blk
->id
) == dsp
->fw_id
&&
2293 region_name
= "global coefficients";
2294 mem
= wm_adsp_find_region(dsp
, type
);
2296 adsp_err(dsp
, "No ZM\n");
2299 reg
= wm_adsp_region_to_reg(mem
, 0);
2302 region_name
= "register";
2311 adsp_dbg(dsp
, "%s.%d: %d bytes in %x for %x\n",
2312 file
, blocks
, le32_to_cpu(blk
->len
),
2313 type
, le32_to_cpu(blk
->id
));
2315 mem
= wm_adsp_find_region(dsp
, type
);
2317 adsp_err(dsp
, "No base for region %x\n", type
);
2321 alg_region
= wm_adsp_find_alg_region(dsp
, type
,
2322 le32_to_cpu(blk
->id
));
2324 reg
= alg_region
->base
;
2325 reg
= wm_adsp_region_to_reg(mem
, reg
);
2328 adsp_err(dsp
, "No %x for algorithm %x\n",
2329 type
, le32_to_cpu(blk
->id
));
2334 adsp_err(dsp
, "%s.%d: Unknown region type %x at %d\n",
2335 file
, blocks
, type
, pos
);
2340 if (le32_to_cpu(blk
->len
) >
2341 firmware
->size
- pos
- sizeof(*blk
)) {
2343 "%s.%d: %s region len %d bytes exceeds file length %zu\n",
2344 file
, blocks
, region_name
,
2345 le32_to_cpu(blk
->len
),
2351 buf
= wm_adsp_buf_alloc(blk
->data
,
2352 le32_to_cpu(blk
->len
),
2355 adsp_err(dsp
, "Out of memory\n");
2360 adsp_dbg(dsp
, "%s.%d: Writing %d bytes at %x\n",
2361 file
, blocks
, le32_to_cpu(blk
->len
),
2363 ret
= regmap_raw_write_async(regmap
, reg
, buf
->buf
,
2364 le32_to_cpu(blk
->len
));
2367 "%s.%d: Failed to write to %x in %s: %d\n",
2368 file
, blocks
, reg
, region_name
, ret
);
2372 pos
+= (le32_to_cpu(blk
->len
) + sizeof(*blk
) + 3) & ~0x03;
2376 ret
= regmap_async_complete(regmap
);
2378 adsp_err(dsp
, "Failed to complete async write: %d\n", ret
);
2380 if (pos
> firmware
->size
)
2381 adsp_warn(dsp
, "%s.%d: %zu bytes at end of file\n",
2382 file
, blocks
, pos
- firmware
->size
);
2384 wm_adsp_debugfs_save_binname(dsp
, file
);
2387 regmap_async_complete(regmap
);
2388 release_firmware(firmware
);
2389 wm_adsp_buf_free(&buf_list
);
2395 static int wm_adsp_create_name(struct wm_adsp
*dsp
)
2400 dsp
->name
= devm_kasprintf(dsp
->dev
, GFP_KERNEL
, "DSP%d",
2406 if (!dsp
->fwf_name
) {
2407 p
= devm_kstrdup(dsp
->dev
, dsp
->name
, GFP_KERNEL
);
2412 for (; *p
!= 0; ++p
)
2419 int wm_adsp1_init(struct wm_adsp
*dsp
)
2423 ret
= wm_adsp_create_name(dsp
);
2427 INIT_LIST_HEAD(&dsp
->alg_regions
);
2429 mutex_init(&dsp
->pwr_lock
);
2433 EXPORT_SYMBOL_GPL(wm_adsp1_init
);
2435 int wm_adsp1_event(struct snd_soc_dapm_widget
*w
,
2436 struct snd_kcontrol
*kcontrol
,
2439 struct snd_soc_component
*component
= snd_soc_dapm_to_component(w
->dapm
);
2440 struct wm_adsp
*dsps
= snd_soc_component_get_drvdata(component
);
2441 struct wm_adsp
*dsp
= &dsps
[w
->shift
];
2442 struct wm_coeff_ctl
*ctl
;
2446 dsp
->component
= component
;
2448 mutex_lock(&dsp
->pwr_lock
);
2451 case SND_SOC_DAPM_POST_PMU
:
2452 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP1_CONTROL_30
,
2453 ADSP1_SYS_ENA
, ADSP1_SYS_ENA
);
2456 * For simplicity set the DSP clock rate to be the
2457 * SYSCLK rate rather than making it configurable.
2459 if (dsp
->sysclk_reg
) {
2460 ret
= regmap_read(dsp
->regmap
, dsp
->sysclk_reg
, &val
);
2462 adsp_err(dsp
, "Failed to read SYSCLK state: %d\n",
2467 val
= (val
& dsp
->sysclk_mask
) >> dsp
->sysclk_shift
;
2469 ret
= regmap_update_bits(dsp
->regmap
,
2470 dsp
->base
+ ADSP1_CONTROL_31
,
2471 ADSP1_CLK_SEL_MASK
, val
);
2473 adsp_err(dsp
, "Failed to set clock rate: %d\n",
2479 ret
= wm_adsp_load(dsp
);
2483 ret
= wm_adsp1_setup_algs(dsp
);
2487 ret
= wm_adsp_load_coeff(dsp
);
2491 /* Initialize caches for enabled and unset controls */
2492 ret
= wm_coeff_init_control_caches(dsp
);
2496 /* Sync set controls */
2497 ret
= wm_coeff_sync_controls(dsp
);
2503 /* Start the core running */
2504 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP1_CONTROL_30
,
2505 ADSP1_CORE_ENA
| ADSP1_START
,
2506 ADSP1_CORE_ENA
| ADSP1_START
);
2508 dsp
->running
= true;
2511 case SND_SOC_DAPM_PRE_PMD
:
2512 dsp
->running
= false;
2513 dsp
->booted
= false;
2516 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP1_CONTROL_30
,
2517 ADSP1_CORE_ENA
| ADSP1_START
, 0);
2519 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP1_CONTROL_19
,
2520 ADSP1_WDMA_BUFFER_LENGTH_MASK
, 0);
2522 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP1_CONTROL_30
,
2525 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
)
2529 wm_adsp_free_alg_regions(dsp
);
2536 mutex_unlock(&dsp
->pwr_lock
);
2541 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP1_CONTROL_30
,
2544 mutex_unlock(&dsp
->pwr_lock
);
2548 EXPORT_SYMBOL_GPL(wm_adsp1_event
);
2550 static int wm_adsp2_ena(struct wm_adsp
*dsp
)
2557 ret
= regmap_update_bits_async(dsp
->regmap
,
2558 dsp
->base
+ ADSP2_CONTROL
,
2559 ADSP2_SYS_ENA
, ADSP2_SYS_ENA
);
2567 /* Wait for the RAM to start, should be near instantaneous */
2568 for (count
= 0; count
< 10; ++count
) {
2569 ret
= regmap_read(dsp
->regmap
, dsp
->base
+ ADSP2_STATUS1
, &val
);
2573 if (val
& ADSP2_RAM_RDY
)
2576 usleep_range(250, 500);
2579 if (!(val
& ADSP2_RAM_RDY
)) {
2580 adsp_err(dsp
, "Failed to start DSP RAM\n");
2584 adsp_dbg(dsp
, "RAM ready after %d polls\n", count
);
2589 static void wm_adsp2_boot_work(struct work_struct
*work
)
2591 struct wm_adsp
*dsp
= container_of(work
,
2596 mutex_lock(&dsp
->pwr_lock
);
2598 ret
= regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2599 ADSP2_MEM_ENA
, ADSP2_MEM_ENA
);
2603 ret
= wm_adsp2_ena(dsp
);
2607 ret
= wm_adsp_load(dsp
);
2611 ret
= wm_adsp2_setup_algs(dsp
);
2615 ret
= wm_adsp_load_coeff(dsp
);
2619 /* Initialize caches for enabled and unset controls */
2620 ret
= wm_coeff_init_control_caches(dsp
);
2626 /* Turn DSP back off until we are ready to run */
2627 ret
= regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2638 mutex_unlock(&dsp
->pwr_lock
);
2643 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2644 ADSP2_SYS_ENA
| ADSP2_CORE_ENA
| ADSP2_START
, 0);
2646 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2649 mutex_unlock(&dsp
->pwr_lock
);
2652 static void wm_adsp2_set_dspclk(struct wm_adsp
*dsp
, unsigned int freq
)
2658 ret
= regmap_update_bits_async(dsp
->regmap
,
2659 dsp
->base
+ ADSP2_CLOCKING
,
2661 freq
<< ADSP2_CLK_SEL_SHIFT
);
2663 adsp_err(dsp
, "Failed to set clock rate: %d\n", ret
);
2668 /* clock is handled by parent codec driver */
2673 int wm_adsp2_preloader_get(struct snd_kcontrol
*kcontrol
,
2674 struct snd_ctl_elem_value
*ucontrol
)
2676 struct snd_soc_component
*component
= snd_soc_kcontrol_component(kcontrol
);
2677 struct wm_adsp
*dsps
= snd_soc_component_get_drvdata(component
);
2678 struct soc_mixer_control
*mc
=
2679 (struct soc_mixer_control
*)kcontrol
->private_value
;
2680 struct wm_adsp
*dsp
= &dsps
[mc
->shift
- 1];
2682 ucontrol
->value
.integer
.value
[0] = dsp
->preloaded
;
2686 EXPORT_SYMBOL_GPL(wm_adsp2_preloader_get
);
2688 int wm_adsp2_preloader_put(struct snd_kcontrol
*kcontrol
,
2689 struct snd_ctl_elem_value
*ucontrol
)
2691 struct snd_soc_component
*component
= snd_soc_kcontrol_component(kcontrol
);
2692 struct wm_adsp
*dsps
= snd_soc_component_get_drvdata(component
);
2693 struct snd_soc_dapm_context
*dapm
= snd_soc_component_get_dapm(component
);
2694 struct soc_mixer_control
*mc
=
2695 (struct soc_mixer_control
*)kcontrol
->private_value
;
2696 struct wm_adsp
*dsp
= &dsps
[mc
->shift
- 1];
2699 snprintf(preload
, ARRAY_SIZE(preload
), "%s Preload", dsp
->name
);
2701 dsp
->preloaded
= ucontrol
->value
.integer
.value
[0];
2703 if (ucontrol
->value
.integer
.value
[0])
2704 snd_soc_component_force_enable_pin(component
, preload
);
2706 snd_soc_component_disable_pin(component
, preload
);
2708 snd_soc_dapm_sync(dapm
);
2710 flush_work(&dsp
->boot_work
);
2714 EXPORT_SYMBOL_GPL(wm_adsp2_preloader_put
);
2716 static void wm_adsp_stop_watchdog(struct wm_adsp
*dsp
)
2723 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_WATCHDOG
,
2724 ADSP2_WDT_ENA_MASK
, 0);
2728 int wm_adsp2_early_event(struct snd_soc_dapm_widget
*w
,
2729 struct snd_kcontrol
*kcontrol
, int event
,
2732 struct snd_soc_component
*component
= snd_soc_dapm_to_component(w
->dapm
);
2733 struct wm_adsp
*dsps
= snd_soc_component_get_drvdata(component
);
2734 struct wm_adsp
*dsp
= &dsps
[w
->shift
];
2735 struct wm_coeff_ctl
*ctl
;
2738 case SND_SOC_DAPM_PRE_PMU
:
2739 wm_adsp2_set_dspclk(dsp
, freq
);
2740 queue_work(system_unbound_wq
, &dsp
->boot_work
);
2742 case SND_SOC_DAPM_PRE_PMD
:
2743 mutex_lock(&dsp
->pwr_lock
);
2745 wm_adsp_debugfs_clear(dsp
);
2748 dsp
->fw_id_version
= 0;
2750 dsp
->booted
= false;
2752 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2755 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
)
2758 wm_adsp_free_alg_regions(dsp
);
2760 mutex_unlock(&dsp
->pwr_lock
);
2762 adsp_dbg(dsp
, "Shutdown complete\n");
2770 EXPORT_SYMBOL_GPL(wm_adsp2_early_event
);
2772 int wm_adsp2_event(struct snd_soc_dapm_widget
*w
,
2773 struct snd_kcontrol
*kcontrol
, int event
)
2775 struct snd_soc_component
*component
= snd_soc_dapm_to_component(w
->dapm
);
2776 struct wm_adsp
*dsps
= snd_soc_component_get_drvdata(component
);
2777 struct wm_adsp
*dsp
= &dsps
[w
->shift
];
2781 case SND_SOC_DAPM_POST_PMU
:
2782 flush_work(&dsp
->boot_work
);
2784 mutex_lock(&dsp
->pwr_lock
);
2791 ret
= wm_adsp2_ena(dsp
);
2795 /* Sync set controls */
2796 ret
= wm_coeff_sync_controls(dsp
);
2800 wm_adsp2_lock(dsp
, dsp
->lock_regions
);
2802 ret
= regmap_update_bits(dsp
->regmap
,
2803 dsp
->base
+ ADSP2_CONTROL
,
2804 ADSP2_CORE_ENA
| ADSP2_START
,
2805 ADSP2_CORE_ENA
| ADSP2_START
);
2809 if (wm_adsp_fw
[dsp
->fw
].num_caps
!= 0) {
2810 ret
= wm_adsp_buffer_init(dsp
);
2815 dsp
->running
= true;
2817 mutex_unlock(&dsp
->pwr_lock
);
2821 case SND_SOC_DAPM_PRE_PMD
:
2822 /* Tell the firmware to cleanup */
2823 wm_adsp_signal_event_controls(dsp
, WM_ADSP_FW_EVENT_SHUTDOWN
);
2825 wm_adsp_stop_watchdog(dsp
);
2827 /* Log firmware state, it can be useful for analysis */
2830 wm_adsp2_show_fw_status(dsp
);
2833 wm_adsp2v2_show_fw_status(dsp
);
2837 mutex_lock(&dsp
->pwr_lock
);
2839 dsp
->running
= false;
2841 regmap_update_bits(dsp
->regmap
,
2842 dsp
->base
+ ADSP2_CONTROL
,
2843 ADSP2_CORE_ENA
| ADSP2_START
, 0);
2845 /* Make sure DMAs are quiesced */
2848 regmap_write(dsp
->regmap
,
2849 dsp
->base
+ ADSP2_RDMA_CONFIG_1
, 0);
2850 regmap_write(dsp
->regmap
,
2851 dsp
->base
+ ADSP2_WDMA_CONFIG_1
, 0);
2852 regmap_write(dsp
->regmap
,
2853 dsp
->base
+ ADSP2_WDMA_CONFIG_2
, 0);
2855 regmap_update_bits(dsp
->regmap
,
2856 dsp
->base
+ ADSP2_CONTROL
,
2860 regmap_write(dsp
->regmap
,
2861 dsp
->base
+ ADSP2_RDMA_CONFIG_1
, 0);
2862 regmap_write(dsp
->regmap
,
2863 dsp
->base
+ ADSP2_WDMA_CONFIG_1
, 0);
2864 regmap_write(dsp
->regmap
,
2865 dsp
->base
+ ADSP2V2_WDMA_CONFIG_2
, 0);
2869 if (wm_adsp_fw
[dsp
->fw
].num_caps
!= 0)
2870 wm_adsp_buffer_free(dsp
);
2872 mutex_unlock(&dsp
->pwr_lock
);
2874 adsp_dbg(dsp
, "Execution stopped\n");
2883 regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2884 ADSP2_SYS_ENA
| ADSP2_CORE_ENA
| ADSP2_START
, 0);
2885 mutex_unlock(&dsp
->pwr_lock
);
2888 EXPORT_SYMBOL_GPL(wm_adsp2_event
);
2890 int wm_adsp2_component_probe(struct wm_adsp
*dsp
, struct snd_soc_component
*component
)
2894 snprintf(preload
, ARRAY_SIZE(preload
), "%s Preload", dsp
->name
);
2895 snd_soc_component_disable_pin(component
, preload
);
2897 wm_adsp2_init_debugfs(dsp
, component
);
2899 dsp
->component
= component
;
2903 EXPORT_SYMBOL_GPL(wm_adsp2_component_probe
);
2905 int wm_adsp2_component_remove(struct wm_adsp
*dsp
, struct snd_soc_component
*component
)
2907 wm_adsp2_cleanup_debugfs(dsp
);
2911 EXPORT_SYMBOL_GPL(wm_adsp2_component_remove
);
2913 int wm_adsp2_init(struct wm_adsp
*dsp
)
2917 ret
= wm_adsp_create_name(dsp
);
2924 * Disable the DSP memory by default when in reset for a small
2927 ret
= regmap_update_bits(dsp
->regmap
, dsp
->base
+ ADSP2_CONTROL
,
2931 "Failed to clear memory retention: %d\n", ret
);
2939 INIT_LIST_HEAD(&dsp
->alg_regions
);
2940 INIT_LIST_HEAD(&dsp
->ctl_list
);
2941 INIT_WORK(&dsp
->boot_work
, wm_adsp2_boot_work
);
2943 mutex_init(&dsp
->pwr_lock
);
2947 EXPORT_SYMBOL_GPL(wm_adsp2_init
);
2949 void wm_adsp2_remove(struct wm_adsp
*dsp
)
2951 struct wm_coeff_ctl
*ctl
;
2953 while (!list_empty(&dsp
->ctl_list
)) {
2954 ctl
= list_first_entry(&dsp
->ctl_list
, struct wm_coeff_ctl
,
2956 list_del(&ctl
->list
);
2957 wm_adsp_free_ctl_blk(ctl
);
2960 EXPORT_SYMBOL_GPL(wm_adsp2_remove
);
2962 static inline int wm_adsp_compr_attached(struct wm_adsp_compr
*compr
)
2964 return compr
->buf
!= NULL
;
2967 static int wm_adsp_compr_attach(struct wm_adsp_compr
*compr
)
2970 * Note this will be more complex once each DSP can support multiple
2973 if (!compr
->dsp
->buffer
)
2976 compr
->buf
= compr
->dsp
->buffer
;
2977 compr
->buf
->compr
= compr
;
2982 static void wm_adsp_compr_detach(struct wm_adsp_compr
*compr
)
2987 /* Wake the poll so it can see buffer is no longer attached */
2989 snd_compr_fragment_elapsed(compr
->stream
);
2991 if (wm_adsp_compr_attached(compr
)) {
2992 compr
->buf
->compr
= NULL
;
2997 int wm_adsp_compr_open(struct wm_adsp
*dsp
, struct snd_compr_stream
*stream
)
2999 struct wm_adsp_compr
*compr
;
3002 mutex_lock(&dsp
->pwr_lock
);
3004 if (wm_adsp_fw
[dsp
->fw
].num_caps
== 0) {
3005 adsp_err(dsp
, "Firmware does not support compressed API\n");
3010 if (wm_adsp_fw
[dsp
->fw
].compr_direction
!= stream
->direction
) {
3011 adsp_err(dsp
, "Firmware does not support stream direction\n");
3017 /* It is expect this limitation will be removed in future */
3018 adsp_err(dsp
, "Only a single stream supported per DSP\n");
3023 compr
= kzalloc(sizeof(*compr
), GFP_KERNEL
);
3030 compr
->stream
= stream
;
3034 stream
->runtime
->private_data
= compr
;
3037 mutex_unlock(&dsp
->pwr_lock
);
3041 EXPORT_SYMBOL_GPL(wm_adsp_compr_open
);
3043 int wm_adsp_compr_free(struct snd_compr_stream
*stream
)
3045 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3046 struct wm_adsp
*dsp
= compr
->dsp
;
3048 mutex_lock(&dsp
->pwr_lock
);
3050 wm_adsp_compr_detach(compr
);
3053 kfree(compr
->raw_buf
);
3056 mutex_unlock(&dsp
->pwr_lock
);
3060 EXPORT_SYMBOL_GPL(wm_adsp_compr_free
);
3062 static int wm_adsp_compr_check_params(struct snd_compr_stream
*stream
,
3063 struct snd_compr_params
*params
)
3065 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3066 struct wm_adsp
*dsp
= compr
->dsp
;
3067 const struct wm_adsp_fw_caps
*caps
;
3068 const struct snd_codec_desc
*desc
;
3071 if (params
->buffer
.fragment_size
< WM_ADSP_MIN_FRAGMENT_SIZE
||
3072 params
->buffer
.fragment_size
> WM_ADSP_MAX_FRAGMENT_SIZE
||
3073 params
->buffer
.fragments
< WM_ADSP_MIN_FRAGMENTS
||
3074 params
->buffer
.fragments
> WM_ADSP_MAX_FRAGMENTS
||
3075 params
->buffer
.fragment_size
% WM_ADSP_DATA_WORD_SIZE
) {
3076 adsp_err(dsp
, "Invalid buffer fragsize=%d fragments=%d\n",
3077 params
->buffer
.fragment_size
,
3078 params
->buffer
.fragments
);
3083 for (i
= 0; i
< wm_adsp_fw
[dsp
->fw
].num_caps
; i
++) {
3084 caps
= &wm_adsp_fw
[dsp
->fw
].caps
[i
];
3087 if (caps
->id
!= params
->codec
.id
)
3090 if (stream
->direction
== SND_COMPRESS_PLAYBACK
) {
3091 if (desc
->max_ch
< params
->codec
.ch_out
)
3094 if (desc
->max_ch
< params
->codec
.ch_in
)
3098 if (!(desc
->formats
& (1 << params
->codec
.format
)))
3101 for (j
= 0; j
< desc
->num_sample_rates
; ++j
)
3102 if (desc
->sample_rates
[j
] == params
->codec
.sample_rate
)
3106 adsp_err(dsp
, "Invalid params id=%u ch=%u,%u rate=%u fmt=%u\n",
3107 params
->codec
.id
, params
->codec
.ch_in
, params
->codec
.ch_out
,
3108 params
->codec
.sample_rate
, params
->codec
.format
);
3112 static inline unsigned int wm_adsp_compr_frag_words(struct wm_adsp_compr
*compr
)
3114 return compr
->size
.fragment_size
/ WM_ADSP_DATA_WORD_SIZE
;
3117 int wm_adsp_compr_set_params(struct snd_compr_stream
*stream
,
3118 struct snd_compr_params
*params
)
3120 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3124 ret
= wm_adsp_compr_check_params(stream
, params
);
3128 compr
->size
= params
->buffer
;
3130 adsp_dbg(compr
->dsp
, "fragment_size=%d fragments=%d\n",
3131 compr
->size
.fragment_size
, compr
->size
.fragments
);
3133 size
= wm_adsp_compr_frag_words(compr
) * sizeof(*compr
->raw_buf
);
3134 compr
->raw_buf
= kmalloc(size
, GFP_DMA
| GFP_KERNEL
);
3135 if (!compr
->raw_buf
)
3138 compr
->sample_rate
= params
->codec
.sample_rate
;
3142 EXPORT_SYMBOL_GPL(wm_adsp_compr_set_params
);
3144 int wm_adsp_compr_get_caps(struct snd_compr_stream
*stream
,
3145 struct snd_compr_caps
*caps
)
3147 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3148 int fw
= compr
->dsp
->fw
;
3151 if (wm_adsp_fw
[fw
].caps
) {
3152 for (i
= 0; i
< wm_adsp_fw
[fw
].num_caps
; i
++)
3153 caps
->codecs
[i
] = wm_adsp_fw
[fw
].caps
[i
].id
;
3155 caps
->num_codecs
= i
;
3156 caps
->direction
= wm_adsp_fw
[fw
].compr_direction
;
3158 caps
->min_fragment_size
= WM_ADSP_MIN_FRAGMENT_SIZE
;
3159 caps
->max_fragment_size
= WM_ADSP_MAX_FRAGMENT_SIZE
;
3160 caps
->min_fragments
= WM_ADSP_MIN_FRAGMENTS
;
3161 caps
->max_fragments
= WM_ADSP_MAX_FRAGMENTS
;
3166 EXPORT_SYMBOL_GPL(wm_adsp_compr_get_caps
);
3168 static int wm_adsp_read_data_block(struct wm_adsp
*dsp
, int mem_type
,
3169 unsigned int mem_addr
,
3170 unsigned int num_words
, u32
*data
)
3172 struct wm_adsp_region
const *mem
= wm_adsp_find_region(dsp
, mem_type
);
3173 unsigned int i
, reg
;
3179 reg
= wm_adsp_region_to_reg(mem
, mem_addr
);
3181 ret
= regmap_raw_read(dsp
->regmap
, reg
, data
,
3182 sizeof(*data
) * num_words
);
3186 for (i
= 0; i
< num_words
; ++i
)
3187 data
[i
] = be32_to_cpu(data
[i
]) & 0x00ffffffu
;
3192 static inline int wm_adsp_read_data_word(struct wm_adsp
*dsp
, int mem_type
,
3193 unsigned int mem_addr
, u32
*data
)
3195 return wm_adsp_read_data_block(dsp
, mem_type
, mem_addr
, 1, data
);
3198 static int wm_adsp_write_data_word(struct wm_adsp
*dsp
, int mem_type
,
3199 unsigned int mem_addr
, u32 data
)
3201 struct wm_adsp_region
const *mem
= wm_adsp_find_region(dsp
, mem_type
);
3207 reg
= wm_adsp_region_to_reg(mem
, mem_addr
);
3209 data
= cpu_to_be32(data
& 0x00ffffffu
);
3211 return regmap_raw_write(dsp
->regmap
, reg
, &data
, sizeof(data
));
3214 static inline int wm_adsp_buffer_read(struct wm_adsp_compr_buf
*buf
,
3215 unsigned int field_offset
, u32
*data
)
3217 return wm_adsp_read_data_word(buf
->dsp
, WMFW_ADSP2_XM
,
3218 buf
->host_buf_ptr
+ field_offset
, data
);
3221 static inline int wm_adsp_buffer_write(struct wm_adsp_compr_buf
*buf
,
3222 unsigned int field_offset
, u32 data
)
3224 return wm_adsp_write_data_word(buf
->dsp
, WMFW_ADSP2_XM
,
3225 buf
->host_buf_ptr
+ field_offset
, data
);
3228 static int wm_adsp_legacy_host_buf_addr(struct wm_adsp_compr_buf
*buf
)
3230 struct wm_adsp_alg_region
*alg_region
;
3231 struct wm_adsp
*dsp
= buf
->dsp
;
3232 u32 xmalg
, addr
, magic
;
3235 alg_region
= wm_adsp_find_alg_region(dsp
, WMFW_ADSP2_XM
, dsp
->fw_id
);
3236 xmalg
= sizeof(struct wm_adsp_system_config_xm_hdr
) / sizeof(__be32
);
3238 addr
= alg_region
->base
+ xmalg
+ ALG_XM_FIELD(magic
);
3239 ret
= wm_adsp_read_data_word(dsp
, WMFW_ADSP2_XM
, addr
, &magic
);
3243 if (magic
!= WM_ADSP_ALG_XM_STRUCT_MAGIC
)
3246 addr
= alg_region
->base
+ xmalg
+ ALG_XM_FIELD(host_buf_ptr
);
3247 for (i
= 0; i
< 5; ++i
) {
3248 ret
= wm_adsp_read_data_word(dsp
, WMFW_ADSP2_XM
, addr
,
3249 &buf
->host_buf_ptr
);
3253 if (buf
->host_buf_ptr
)
3256 usleep_range(1000, 2000);
3259 if (!buf
->host_buf_ptr
)
3262 adsp_dbg(dsp
, "host_buf_ptr=%x\n", buf
->host_buf_ptr
);
3267 static struct wm_coeff_ctl
*
3268 wm_adsp_find_host_buffer_ctrl(struct wm_adsp_compr_buf
*buf
)
3270 struct wm_adsp
*dsp
= buf
->dsp
;
3271 struct wm_coeff_ctl
*ctl
;
3273 list_for_each_entry(ctl
, &dsp
->ctl_list
, list
) {
3274 if (ctl
->type
!= WMFW_CTL_TYPE_HOST_BUFFER
)
3286 static int wm_adsp_buffer_locate(struct wm_adsp_compr_buf
*buf
)
3288 struct wm_adsp
*dsp
= buf
->dsp
;
3289 struct wm_coeff_ctl
*ctl
;
3294 ctl
= wm_adsp_find_host_buffer_ctrl(buf
);
3296 return wm_adsp_legacy_host_buf_addr(buf
);
3298 ret
= wm_coeff_base_reg(ctl
, ®
);
3302 for (i
= 0; i
< 5; ++i
) {
3303 ret
= regmap_raw_read(dsp
->regmap
, reg
, &val
, sizeof(val
));
3310 usleep_range(1000, 2000);
3316 buf
->host_buf_ptr
= be32_to_cpu(val
);
3317 adsp_dbg(dsp
, "host_buf_ptr=%x\n", buf
->host_buf_ptr
);
3322 static int wm_adsp_buffer_populate(struct wm_adsp_compr_buf
*buf
)
3324 const struct wm_adsp_fw_caps
*caps
= wm_adsp_fw
[buf
->dsp
->fw
].caps
;
3325 struct wm_adsp_buffer_region
*region
;
3329 for (i
= 0; i
< caps
->num_regions
; ++i
) {
3330 region
= &buf
->regions
[i
];
3332 region
->offset
= offset
;
3333 region
->mem_type
= caps
->region_defs
[i
].mem_type
;
3335 ret
= wm_adsp_buffer_read(buf
, caps
->region_defs
[i
].base_offset
,
3336 ®ion
->base_addr
);
3340 ret
= wm_adsp_buffer_read(buf
, caps
->region_defs
[i
].size_offset
,
3345 region
->cumulative_size
= offset
;
3348 "region=%d type=%d base=%04x off=%04x size=%04x\n",
3349 i
, region
->mem_type
, region
->base_addr
,
3350 region
->offset
, region
->cumulative_size
);
3356 static void wm_adsp_buffer_clear(struct wm_adsp_compr_buf
*buf
)
3358 buf
->irq_count
= 0xFFFFFFFF;
3359 buf
->read_index
= -1;
3363 static int wm_adsp_buffer_init(struct wm_adsp
*dsp
)
3365 struct wm_adsp_compr_buf
*buf
;
3368 buf
= kzalloc(sizeof(*buf
), GFP_KERNEL
);
3374 wm_adsp_buffer_clear(buf
);
3376 ret
= wm_adsp_buffer_locate(buf
);
3378 adsp_err(dsp
, "Failed to acquire host buffer: %d\n", ret
);
3382 buf
->regions
= kcalloc(wm_adsp_fw
[dsp
->fw
].caps
->num_regions
,
3383 sizeof(*buf
->regions
), GFP_KERNEL
);
3384 if (!buf
->regions
) {
3389 ret
= wm_adsp_buffer_populate(buf
);
3391 adsp_err(dsp
, "Failed to populate host buffer: %d\n", ret
);
3400 kfree(buf
->regions
);
3406 static int wm_adsp_buffer_free(struct wm_adsp
*dsp
)
3409 wm_adsp_compr_detach(dsp
->buffer
->compr
);
3411 kfree(dsp
->buffer
->regions
);
3420 int wm_adsp_compr_trigger(struct snd_compr_stream
*stream
, int cmd
)
3422 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3423 struct wm_adsp
*dsp
= compr
->dsp
;
3426 adsp_dbg(dsp
, "Trigger: %d\n", cmd
);
3428 mutex_lock(&dsp
->pwr_lock
);
3431 case SNDRV_PCM_TRIGGER_START
:
3432 if (!wm_adsp_compr_attached(compr
)) {
3433 ret
= wm_adsp_compr_attach(compr
);
3435 adsp_err(dsp
, "Failed to link buffer and stream: %d\n",
3441 wm_adsp_buffer_clear(compr
->buf
);
3443 /* Trigger the IRQ at one fragment of data */
3444 ret
= wm_adsp_buffer_write(compr
->buf
,
3445 HOST_BUFFER_FIELD(high_water_mark
),
3446 wm_adsp_compr_frag_words(compr
));
3448 adsp_err(dsp
, "Failed to set high water mark: %d\n",
3453 case SNDRV_PCM_TRIGGER_STOP
:
3460 mutex_unlock(&dsp
->pwr_lock
);
3464 EXPORT_SYMBOL_GPL(wm_adsp_compr_trigger
);
3466 static inline int wm_adsp_buffer_size(struct wm_adsp_compr_buf
*buf
)
3468 int last_region
= wm_adsp_fw
[buf
->dsp
->fw
].caps
->num_regions
- 1;
3470 return buf
->regions
[last_region
].cumulative_size
;
3473 static int wm_adsp_buffer_update_avail(struct wm_adsp_compr_buf
*buf
)
3475 u32 next_read_index
, next_write_index
;
3476 int write_index
, read_index
, avail
;
3479 /* Only sync read index if we haven't already read a valid index */
3480 if (buf
->read_index
< 0) {
3481 ret
= wm_adsp_buffer_read(buf
,
3482 HOST_BUFFER_FIELD(next_read_index
),
3487 read_index
= sign_extend32(next_read_index
, 23);
3489 if (read_index
< 0) {
3490 adsp_dbg(buf
->dsp
, "Avail check on unstarted stream\n");
3494 buf
->read_index
= read_index
;
3497 ret
= wm_adsp_buffer_read(buf
, HOST_BUFFER_FIELD(next_write_index
),
3502 write_index
= sign_extend32(next_write_index
, 23);
3504 avail
= write_index
- buf
->read_index
;
3506 avail
+= wm_adsp_buffer_size(buf
);
3508 adsp_dbg(buf
->dsp
, "readindex=0x%x, writeindex=0x%x, avail=%d\n",
3509 buf
->read_index
, write_index
, avail
* WM_ADSP_DATA_WORD_SIZE
);
3516 static int wm_adsp_buffer_get_error(struct wm_adsp_compr_buf
*buf
)
3520 ret
= wm_adsp_buffer_read(buf
, HOST_BUFFER_FIELD(error
), &buf
->error
);
3522 adsp_err(buf
->dsp
, "Failed to check buffer error: %d\n", ret
);
3525 if (buf
->error
!= 0) {
3526 adsp_err(buf
->dsp
, "Buffer error occurred: %d\n", buf
->error
);
3533 int wm_adsp_compr_handle_irq(struct wm_adsp
*dsp
)
3535 struct wm_adsp_compr_buf
*buf
;
3536 struct wm_adsp_compr
*compr
;
3539 mutex_lock(&dsp
->pwr_lock
);
3549 adsp_dbg(dsp
, "Handling buffer IRQ\n");
3551 ret
= wm_adsp_buffer_get_error(buf
);
3553 goto out_notify
; /* Wake poll to report error */
3555 ret
= wm_adsp_buffer_read(buf
, HOST_BUFFER_FIELD(irq_count
),
3558 adsp_err(dsp
, "Failed to get irq_count: %d\n", ret
);
3562 ret
= wm_adsp_buffer_update_avail(buf
);
3564 adsp_err(dsp
, "Error reading avail: %d\n", ret
);
3568 if (wm_adsp_fw
[dsp
->fw
].voice_trigger
&& buf
->irq_count
== 2)
3569 ret
= WM_ADSP_COMPR_VOICE_TRIGGER
;
3572 if (compr
&& compr
->stream
)
3573 snd_compr_fragment_elapsed(compr
->stream
);
3576 mutex_unlock(&dsp
->pwr_lock
);
3580 EXPORT_SYMBOL_GPL(wm_adsp_compr_handle_irq
);
3582 static int wm_adsp_buffer_reenable_irq(struct wm_adsp_compr_buf
*buf
)
3584 if (buf
->irq_count
& 0x01)
3587 adsp_dbg(buf
->dsp
, "Enable IRQ(0x%x) for next fragment\n",
3590 buf
->irq_count
|= 0x01;
3592 return wm_adsp_buffer_write(buf
, HOST_BUFFER_FIELD(irq_ack
),
3596 int wm_adsp_compr_pointer(struct snd_compr_stream
*stream
,
3597 struct snd_compr_tstamp
*tstamp
)
3599 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3600 struct wm_adsp
*dsp
= compr
->dsp
;
3601 struct wm_adsp_compr_buf
*buf
;
3604 adsp_dbg(dsp
, "Pointer request\n");
3606 mutex_lock(&dsp
->pwr_lock
);
3610 if (!compr
->buf
|| compr
->buf
->error
) {
3611 snd_compr_stop_error(stream
, SNDRV_PCM_STATE_XRUN
);
3616 if (buf
->avail
< wm_adsp_compr_frag_words(compr
)) {
3617 ret
= wm_adsp_buffer_update_avail(buf
);
3619 adsp_err(dsp
, "Error reading avail: %d\n", ret
);
3624 * If we really have less than 1 fragment available tell the
3625 * DSP to inform us once a whole fragment is available.
3627 if (buf
->avail
< wm_adsp_compr_frag_words(compr
)) {
3628 ret
= wm_adsp_buffer_get_error(buf
);
3630 if (compr
->buf
->error
)
3631 snd_compr_stop_error(stream
,
3632 SNDRV_PCM_STATE_XRUN
);
3636 ret
= wm_adsp_buffer_reenable_irq(buf
);
3639 "Failed to re-enable buffer IRQ: %d\n",
3646 tstamp
->copied_total
= compr
->copied_total
;
3647 tstamp
->copied_total
+= buf
->avail
* WM_ADSP_DATA_WORD_SIZE
;
3648 tstamp
->sampling_rate
= compr
->sample_rate
;
3651 mutex_unlock(&dsp
->pwr_lock
);
3655 EXPORT_SYMBOL_GPL(wm_adsp_compr_pointer
);
3657 static int wm_adsp_buffer_capture_block(struct wm_adsp_compr
*compr
, int target
)
3659 struct wm_adsp_compr_buf
*buf
= compr
->buf
;
3660 u8
*pack_in
= (u8
*)compr
->raw_buf
;
3661 u8
*pack_out
= (u8
*)compr
->raw_buf
;
3662 unsigned int adsp_addr
;
3663 int mem_type
, nwords
, max_read
;
3666 /* Calculate read parameters */
3667 for (i
= 0; i
< wm_adsp_fw
[buf
->dsp
->fw
].caps
->num_regions
; ++i
)
3668 if (buf
->read_index
< buf
->regions
[i
].cumulative_size
)
3671 if (i
== wm_adsp_fw
[buf
->dsp
->fw
].caps
->num_regions
)
3674 mem_type
= buf
->regions
[i
].mem_type
;
3675 adsp_addr
= buf
->regions
[i
].base_addr
+
3676 (buf
->read_index
- buf
->regions
[i
].offset
);
3678 max_read
= wm_adsp_compr_frag_words(compr
);
3679 nwords
= buf
->regions
[i
].cumulative_size
- buf
->read_index
;
3681 if (nwords
> target
)
3683 if (nwords
> buf
->avail
)
3684 nwords
= buf
->avail
;
3685 if (nwords
> max_read
)
3690 /* Read data from DSP */
3691 ret
= wm_adsp_read_data_block(buf
->dsp
, mem_type
, adsp_addr
,
3692 nwords
, compr
->raw_buf
);
3696 /* Remove the padding bytes from the data read from the DSP */
3697 for (i
= 0; i
< nwords
; i
++) {
3698 for (j
= 0; j
< WM_ADSP_DATA_WORD_SIZE
; j
++)
3699 *pack_out
++ = *pack_in
++;
3701 pack_in
+= sizeof(*(compr
->raw_buf
)) - WM_ADSP_DATA_WORD_SIZE
;
3704 /* update read index to account for words read */
3705 buf
->read_index
+= nwords
;
3706 if (buf
->read_index
== wm_adsp_buffer_size(buf
))
3707 buf
->read_index
= 0;
3709 ret
= wm_adsp_buffer_write(buf
, HOST_BUFFER_FIELD(next_read_index
),
3714 /* update avail to account for words read */
3715 buf
->avail
-= nwords
;
3720 static int wm_adsp_compr_read(struct wm_adsp_compr
*compr
,
3721 char __user
*buf
, size_t count
)
3723 struct wm_adsp
*dsp
= compr
->dsp
;
3727 adsp_dbg(dsp
, "Requested read of %zu bytes\n", count
);
3729 if (!compr
->buf
|| compr
->buf
->error
) {
3730 snd_compr_stop_error(compr
->stream
, SNDRV_PCM_STATE_XRUN
);
3734 count
/= WM_ADSP_DATA_WORD_SIZE
;
3737 nwords
= wm_adsp_buffer_capture_block(compr
, count
);
3739 adsp_err(dsp
, "Failed to capture block: %d\n", nwords
);
3743 nbytes
= nwords
* WM_ADSP_DATA_WORD_SIZE
;
3745 adsp_dbg(dsp
, "Read %d bytes\n", nbytes
);
3747 if (copy_to_user(buf
+ ntotal
, compr
->raw_buf
, nbytes
)) {
3748 adsp_err(dsp
, "Failed to copy data to user: %d, %d\n",
3755 } while (nwords
> 0 && count
> 0);
3757 compr
->copied_total
+= ntotal
;
3762 int wm_adsp_compr_copy(struct snd_compr_stream
*stream
, char __user
*buf
,
3765 struct wm_adsp_compr
*compr
= stream
->runtime
->private_data
;
3766 struct wm_adsp
*dsp
= compr
->dsp
;
3769 mutex_lock(&dsp
->pwr_lock
);
3771 if (stream
->direction
== SND_COMPRESS_CAPTURE
)
3772 ret
= wm_adsp_compr_read(compr
, buf
, count
);
3776 mutex_unlock(&dsp
->pwr_lock
);
3780 EXPORT_SYMBOL_GPL(wm_adsp_compr_copy
);
3782 int wm_adsp2_lock(struct wm_adsp
*dsp
, unsigned int lock_regions
)
3784 struct regmap
*regmap
= dsp
->regmap
;
3785 unsigned int code0
, code1
, lock_reg
;
3787 if (!(lock_regions
& WM_ADSP2_REGION_ALL
))
3790 lock_regions
&= WM_ADSP2_REGION_ALL
;
3791 lock_reg
= dsp
->base
+ ADSP2_LOCK_REGION_1_LOCK_REGION_0
;
3793 while (lock_regions
) {
3795 if (lock_regions
& BIT(0)) {
3796 code0
= ADSP2_LOCK_CODE_0
;
3797 code1
= ADSP2_LOCK_CODE_1
;
3799 if (lock_regions
& BIT(1)) {
3800 code0
|= ADSP2_LOCK_CODE_0
<< ADSP2_LOCK_REGION_SHIFT
;
3801 code1
|= ADSP2_LOCK_CODE_1
<< ADSP2_LOCK_REGION_SHIFT
;
3803 regmap_write(regmap
, lock_reg
, code0
);
3804 regmap_write(regmap
, lock_reg
, code1
);
3811 EXPORT_SYMBOL_GPL(wm_adsp2_lock
);
3813 irqreturn_t
wm_adsp2_bus_error(struct wm_adsp
*dsp
)
3816 struct regmap
*regmap
= dsp
->regmap
;
3819 ret
= regmap_read(regmap
, dsp
->base
+ ADSP2_LOCK_REGION_CTRL
, &val
);
3822 "Failed to read Region Lock Ctrl register: %d\n", ret
);
3826 if (val
& ADSP2_WDT_TIMEOUT_STS_MASK
) {
3827 adsp_err(dsp
, "watchdog timeout error\n");
3828 wm_adsp_stop_watchdog(dsp
);
3831 if (val
& (ADSP2_SLAVE_ERR_MASK
| ADSP2_REGION_LOCK_ERR_MASK
)) {
3832 if (val
& ADSP2_SLAVE_ERR_MASK
)
3833 adsp_err(dsp
, "bus error: slave error\n");
3835 adsp_err(dsp
, "bus error: region lock error\n");
3837 ret
= regmap_read(regmap
, dsp
->base
+ ADSP2_BUS_ERR_ADDR
, &val
);
3840 "Failed to read Bus Err Addr register: %d\n",
3845 adsp_err(dsp
, "bus error address = 0x%x\n",
3846 val
& ADSP2_BUS_ERR_ADDR_MASK
);
3848 ret
= regmap_read(regmap
,
3849 dsp
->base
+ ADSP2_PMEM_ERR_ADDR_XMEM_ERR_ADDR
,
3853 "Failed to read Pmem Xmem Err Addr register: %d\n",
3858 adsp_err(dsp
, "xmem error address = 0x%x\n",
3859 val
& ADSP2_XMEM_ERR_ADDR_MASK
);
3860 adsp_err(dsp
, "pmem error address = 0x%x\n",
3861 (val
& ADSP2_PMEM_ERR_ADDR_MASK
) >>
3862 ADSP2_PMEM_ERR_ADDR_SHIFT
);
3865 regmap_update_bits(regmap
, dsp
->base
+ ADSP2_LOCK_REGION_CTRL
,
3866 ADSP2_CTRL_ERR_EINT
, ADSP2_CTRL_ERR_EINT
);
3870 EXPORT_SYMBOL_GPL(wm_adsp2_bus_error
);
3872 MODULE_LICENSE("GPL v2");