~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/codecs/wm_adsp.c

Version: ~ [ linux-5.8-rc3 ] ~ [ linux-5.7.5 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.48 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.129 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.185 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.228 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.228 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * wm_adsp.c  --  Wolfson ADSP support
  3  *
  4  * Copyright 2012 Wolfson Microelectronics plc
  5  *
  6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  7  *
  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.
 11  */
 12 
 13 #include <linux/module.h>
 14 #include <linux/moduleparam.h>
 15 #include <linux/init.h>
 16 #include <linux/delay.h>
 17 #include <linux/firmware.h>
 18 #include <linux/list.h>
 19 #include <linux/pm.h>
 20 #include <linux/pm_runtime.h>
 21 #include <linux/regmap.h>
 22 #include <linux/regulator/consumer.h>
 23 #include <linux/slab.h>
 24 #include <linux/vmalloc.h>
 25 #include <linux/workqueue.h>
 26 #include <linux/debugfs.h>
 27 #include <sound/core.h>
 28 #include <sound/pcm.h>
 29 #include <sound/pcm_params.h>
 30 #include <sound/soc.h>
 31 #include <sound/jack.h>
 32 #include <sound/initval.h>
 33 #include <sound/tlv.h>
 34 
 35 #include "wm_adsp.h"
 36 
 37 #define adsp_crit(_dsp, fmt, ...) \
 38         dev_crit(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)
 39 #define adsp_err(_dsp, fmt, ...) \
 40         dev_err(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)
 41 #define adsp_warn(_dsp, fmt, ...) \
 42         dev_warn(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)
 43 #define adsp_info(_dsp, fmt, ...) \
 44         dev_info(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)
 45 #define adsp_dbg(_dsp, fmt, ...) \
 46         dev_dbg(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)
 47 
 48 #define ADSP1_CONTROL_1                   0x00
 49 #define ADSP1_CONTROL_2                   0x02
 50 #define ADSP1_CONTROL_3                   0x03
 51 #define ADSP1_CONTROL_4                   0x04
 52 #define ADSP1_CONTROL_5                   0x06
 53 #define ADSP1_CONTROL_6                   0x07
 54 #define ADSP1_CONTROL_7                   0x08
 55 #define ADSP1_CONTROL_8                   0x09
 56 #define ADSP1_CONTROL_9                   0x0A
 57 #define ADSP1_CONTROL_10                  0x0B
 58 #define ADSP1_CONTROL_11                  0x0C
 59 #define ADSP1_CONTROL_12                  0x0D
 60 #define ADSP1_CONTROL_13                  0x0F
 61 #define ADSP1_CONTROL_14                  0x10
 62 #define ADSP1_CONTROL_15                  0x11
 63 #define ADSP1_CONTROL_16                  0x12
 64 #define ADSP1_CONTROL_17                  0x13
 65 #define ADSP1_CONTROL_18                  0x14
 66 #define ADSP1_CONTROL_19                  0x16
 67 #define ADSP1_CONTROL_20                  0x17
 68 #define ADSP1_CONTROL_21                  0x18
 69 #define ADSP1_CONTROL_22                  0x1A
 70 #define ADSP1_CONTROL_23                  0x1B
 71 #define ADSP1_CONTROL_24                  0x1C
 72 #define ADSP1_CONTROL_25                  0x1E
 73 #define ADSP1_CONTROL_26                  0x20
 74 #define ADSP1_CONTROL_27                  0x21
 75 #define ADSP1_CONTROL_28                  0x22
 76 #define ADSP1_CONTROL_29                  0x23
 77 #define ADSP1_CONTROL_30                  0x24
 78 #define ADSP1_CONTROL_31                  0x26
 79 
 80 /*
 81  * ADSP1 Control 19
 82  */
 83 #define ADSP1_WDMA_BUFFER_LENGTH_MASK     0x00FF  /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */
 84 #define ADSP1_WDMA_BUFFER_LENGTH_SHIFT         0  /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */
 85 #define ADSP1_WDMA_BUFFER_LENGTH_WIDTH         8  /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */
 86 
 87 
 88 /*
 89  * ADSP1 Control 30
 90  */
 91 #define ADSP1_DBG_CLK_ENA                 0x0008  /* DSP1_DBG_CLK_ENA */
 92 #define ADSP1_DBG_CLK_ENA_MASK            0x0008  /* DSP1_DBG_CLK_ENA */
 93 #define ADSP1_DBG_CLK_ENA_SHIFT                3  /* DSP1_DBG_CLK_ENA */
 94 #define ADSP1_DBG_CLK_ENA_WIDTH                1  /* DSP1_DBG_CLK_ENA */
 95 #define ADSP1_SYS_ENA                     0x0004  /* DSP1_SYS_ENA */
 96 #define ADSP1_SYS_ENA_MASK                0x0004  /* DSP1_SYS_ENA */
 97 #define ADSP1_SYS_ENA_SHIFT                    2  /* DSP1_SYS_ENA */
 98 #define ADSP1_SYS_ENA_WIDTH                    1  /* DSP1_SYS_ENA */
 99 #define ADSP1_CORE_ENA                    0x0002  /* DSP1_CORE_ENA */
100 #define ADSP1_CORE_ENA_MASK               0x0002  /* DSP1_CORE_ENA */
101 #define ADSP1_CORE_ENA_SHIFT                   1  /* DSP1_CORE_ENA */
102 #define ADSP1_CORE_ENA_WIDTH                   1  /* DSP1_CORE_ENA */
103 #define ADSP1_START                       0x0001  /* DSP1_START */
104 #define ADSP1_START_MASK                  0x0001  /* DSP1_START */
105 #define ADSP1_START_SHIFT                      0  /* DSP1_START */
106 #define ADSP1_START_WIDTH                      1  /* DSP1_START */
107 
108 /*
109  * ADSP1 Control 31
110  */
111 #define ADSP1_CLK_SEL_MASK                0x0007  /* CLK_SEL_ENA */
112 #define ADSP1_CLK_SEL_SHIFT                    0  /* CLK_SEL_ENA */
113 #define ADSP1_CLK_SEL_WIDTH                    3  /* CLK_SEL_ENA */
114 
115 #define ADSP2_CONTROL        0x0
116 #define ADSP2_CLOCKING       0x1
117 #define ADSP2_STATUS1        0x4
118 #define ADSP2_WDMA_CONFIG_1 0x30
119 #define ADSP2_WDMA_CONFIG_2 0x31
120 #define ADSP2_RDMA_CONFIG_1 0x34
121 
122 #define ADSP2_SCRATCH0        0x40
123 #define ADSP2_SCRATCH1        0x41
124 #define ADSP2_SCRATCH2        0x42
125 #define ADSP2_SCRATCH3        0x43
126 
127 /*
128  * ADSP2 Control
129  */
130 
131 #define ADSP2_MEM_ENA                     0x0010  /* DSP1_MEM_ENA */
132 #define ADSP2_MEM_ENA_MASK                0x0010  /* DSP1_MEM_ENA */
133 #define ADSP2_MEM_ENA_SHIFT                    4  /* DSP1_MEM_ENA */
134 #define ADSP2_MEM_ENA_WIDTH                    1  /* DSP1_MEM_ENA */
135 #define ADSP2_SYS_ENA                     0x0004  /* DSP1_SYS_ENA */
136 #define ADSP2_SYS_ENA_MASK                0x0004  /* DSP1_SYS_ENA */
137 #define ADSP2_SYS_ENA_SHIFT                    2  /* DSP1_SYS_ENA */
138 #define ADSP2_SYS_ENA_WIDTH                    1  /* DSP1_SYS_ENA */
139 #define ADSP2_CORE_ENA                    0x0002  /* DSP1_CORE_ENA */
140 #define ADSP2_CORE_ENA_MASK               0x0002  /* DSP1_CORE_ENA */
141 #define ADSP2_CORE_ENA_SHIFT                   1  /* DSP1_CORE_ENA */
142 #define ADSP2_CORE_ENA_WIDTH                   1  /* DSP1_CORE_ENA */
143 #define ADSP2_START                       0x0001  /* DSP1_START */
144 #define ADSP2_START_MASK                  0x0001  /* DSP1_START */
145 #define ADSP2_START_SHIFT                      0  /* DSP1_START */
146 #define ADSP2_START_WIDTH                      1  /* DSP1_START */
147 
148 /*
149  * ADSP2 clocking
150  */
151 #define ADSP2_CLK_SEL_MASK                0x0007  /* CLK_SEL_ENA */
152 #define ADSP2_CLK_SEL_SHIFT                    0  /* CLK_SEL_ENA */
153 #define ADSP2_CLK_SEL_WIDTH                    3  /* CLK_SEL_ENA */
154 
155 /*
156  * ADSP2 Status 1
157  */
158 #define ADSP2_RAM_RDY                     0x0001
159 #define ADSP2_RAM_RDY_MASK                0x0001
160 #define ADSP2_RAM_RDY_SHIFT                    0
161 #define ADSP2_RAM_RDY_WIDTH                    1
162 
163 #define ADSP_MAX_STD_CTRL_SIZE               512
164 
165 struct wm_adsp_buf {
166         struct list_head list;
167         void *buf;
168 };
169 
170 static struct wm_adsp_buf *wm_adsp_buf_alloc(const void *src, size_t len,
171                                              struct list_head *list)
172 {
173         struct wm_adsp_buf *buf = kzalloc(sizeof(*buf), GFP_KERNEL);
174 
175         if (buf == NULL)
176                 return NULL;
177 
178         buf->buf = vmalloc(len);
179         if (!buf->buf) {
180                 vfree(buf);
181                 return NULL;
182         }
183         memcpy(buf->buf, src, len);
184 
185         if (list)
186                 list_add_tail(&buf->list, list);
187 
188         return buf;
189 }
190 
191 static void wm_adsp_buf_free(struct list_head *list)
192 {
193         while (!list_empty(list)) {
194                 struct wm_adsp_buf *buf = list_first_entry(list,
195                                                            struct wm_adsp_buf,
196                                                            list);
197                 list_del(&buf->list);
198                 vfree(buf->buf);
199                 kfree(buf);
200         }
201 }
202 
203 #define WM_ADSP_FW_MBC_VSS  0
204 #define WM_ADSP_FW_HIFI     1
205 #define WM_ADSP_FW_TX       2
206 #define WM_ADSP_FW_TX_SPK   3
207 #define WM_ADSP_FW_RX       4
208 #define WM_ADSP_FW_RX_ANC   5
209 #define WM_ADSP_FW_CTRL     6
210 #define WM_ADSP_FW_ASR      7
211 #define WM_ADSP_FW_TRACE    8
212 #define WM_ADSP_FW_SPK_PROT 9
213 #define WM_ADSP_FW_MISC     10
214 
215 #define WM_ADSP_NUM_FW      11
216 
217 static const char *wm_adsp_fw_text[WM_ADSP_NUM_FW] = {
218         [WM_ADSP_FW_MBC_VSS] =  "MBC/VSS",
219         [WM_ADSP_FW_HIFI] =     "MasterHiFi",
220         [WM_ADSP_FW_TX] =       "Tx",
221         [WM_ADSP_FW_TX_SPK] =   "Tx Speaker",
222         [WM_ADSP_FW_RX] =       "Rx",
223         [WM_ADSP_FW_RX_ANC] =   "Rx ANC",
224         [WM_ADSP_FW_CTRL] =     "Voice Ctrl",
225         [WM_ADSP_FW_ASR] =      "ASR Assist",
226         [WM_ADSP_FW_TRACE] =    "Dbg Trace",
227         [WM_ADSP_FW_SPK_PROT] = "Protection",
228         [WM_ADSP_FW_MISC] =     "Misc",
229 };
230 
231 struct wm_adsp_system_config_xm_hdr {
232         __be32 sys_enable;
233         __be32 fw_id;
234         __be32 fw_rev;
235         __be32 boot_status;
236         __be32 watchdog;
237         __be32 dma_buffer_size;
238         __be32 rdma[6];
239         __be32 wdma[8];
240         __be32 build_job_name[3];
241         __be32 build_job_number;
242 };
243 
244 struct wm_adsp_alg_xm_struct {
245         __be32 magic;
246         __be32 smoothing;
247         __be32 threshold;
248         __be32 host_buf_ptr;
249         __be32 start_seq;
250         __be32 high_water_mark;
251         __be32 low_water_mark;
252         __be64 smoothed_power;
253 };
254 
255 struct wm_adsp_buffer {
256         __be32 X_buf_base;              /* XM base addr of first X area */
257         __be32 X_buf_size;              /* Size of 1st X area in words */
258         __be32 X_buf_base2;             /* XM base addr of 2nd X area */
259         __be32 X_buf_brk;               /* Total X size in words */
260         __be32 Y_buf_base;              /* YM base addr of Y area */
261         __be32 wrap;                    /* Total size X and Y in words */
262         __be32 high_water_mark;         /* Point at which IRQ is asserted */
263         __be32 irq_count;               /* bits 1-31 count IRQ assertions */
264         __be32 irq_ack;                 /* acked IRQ count, bit 0 enables IRQ */
265         __be32 next_write_index;        /* word index of next write */
266         __be32 next_read_index;         /* word index of next read */
267         __be32 error;                   /* error if any */
268         __be32 oldest_block_index;      /* word index of oldest surviving */
269         __be32 requested_rewind;        /* how many blocks rewind was done */
270         __be32 reserved_space;          /* internal */
271         __be32 min_free;                /* min free space since stream start */
272         __be32 blocks_written[2];       /* total blocks written (64 bit) */
273         __be32 words_written[2];        /* total words written (64 bit) */
274 };
275 
276 struct wm_adsp_compr;
277 
278 struct wm_adsp_compr_buf {
279         struct wm_adsp *dsp;
280         struct wm_adsp_compr *compr;
281 
282         struct wm_adsp_buffer_region *regions;
283         u32 host_buf_ptr;
284 
285         u32 error;
286         u32 irq_count;
287         int read_index;
288         int avail;
289 };
290 
291 struct wm_adsp_compr {
292         struct wm_adsp *dsp;
293         struct wm_adsp_compr_buf *buf;
294 
295         struct snd_compr_stream *stream;
296         struct snd_compressed_buffer size;
297 
298         u32 *raw_buf;
299         unsigned int copied_total;
300 
301         unsigned int sample_rate;
302 };
303 
304 #define WM_ADSP_DATA_WORD_SIZE         3
305 
306 #define WM_ADSP_MIN_FRAGMENTS          1
307 #define WM_ADSP_MAX_FRAGMENTS          256
308 #define WM_ADSP_MIN_FRAGMENT_SIZE      (64 * WM_ADSP_DATA_WORD_SIZE)
309 #define WM_ADSP_MAX_FRAGMENT_SIZE      (4096 * WM_ADSP_DATA_WORD_SIZE)
310 
311 #define WM_ADSP_ALG_XM_STRUCT_MAGIC    0x49aec7
312 
313 #define HOST_BUFFER_FIELD(field) \
314         (offsetof(struct wm_adsp_buffer, field) / sizeof(__be32))
315 
316 #define ALG_XM_FIELD(field) \
317         (offsetof(struct wm_adsp_alg_xm_struct, field) / sizeof(__be32))
318 
319 static int wm_adsp_buffer_init(struct wm_adsp *dsp);
320 static int wm_adsp_buffer_free(struct wm_adsp *dsp);
321 
322 struct wm_adsp_buffer_region {
323         unsigned int offset;
324         unsigned int cumulative_size;
325         unsigned int mem_type;
326         unsigned int base_addr;
327 };
328 
329 struct wm_adsp_buffer_region_def {
330         unsigned int mem_type;
331         unsigned int base_offset;
332         unsigned int size_offset;
333 };
334 
335 static const struct wm_adsp_buffer_region_def default_regions[] = {
336         {
337                 .mem_type = WMFW_ADSP2_XM,
338                 .base_offset = HOST_BUFFER_FIELD(X_buf_base),
339                 .size_offset = HOST_BUFFER_FIELD(X_buf_size),
340         },
341         {
342                 .mem_type = WMFW_ADSP2_XM,
343                 .base_offset = HOST_BUFFER_FIELD(X_buf_base2),
344                 .size_offset = HOST_BUFFER_FIELD(X_buf_brk),
345         },
346         {
347                 .mem_type = WMFW_ADSP2_YM,
348                 .base_offset = HOST_BUFFER_FIELD(Y_buf_base),
349                 .size_offset = HOST_BUFFER_FIELD(wrap),
350         },
351 };
352 
353 struct wm_adsp_fw_caps {
354         u32 id;
355         struct snd_codec_desc desc;
356         int num_regions;
357         const struct wm_adsp_buffer_region_def *region_defs;
358 };
359 
360 static const struct wm_adsp_fw_caps ctrl_caps[] = {
361         {
362                 .id = SND_AUDIOCODEC_BESPOKE,
363                 .desc = {
364                         .max_ch = 1,
365                         .sample_rates = { 16000 },
366                         .num_sample_rates = 1,
367                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
368                 },
369                 .num_regions = ARRAY_SIZE(default_regions),
370                 .region_defs = default_regions,
371         },
372 };
373 
374 static const struct wm_adsp_fw_caps trace_caps[] = {
375         {
376                 .id = SND_AUDIOCODEC_BESPOKE,
377                 .desc = {
378                         .max_ch = 8,
379                         .sample_rates = {
380                                 4000, 8000, 11025, 12000, 16000, 22050,
381                                 24000, 32000, 44100, 48000, 64000, 88200,
382                                 96000, 176400, 192000
383                         },
384                         .num_sample_rates = 15,
385                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
386                 },
387                 .num_regions = ARRAY_SIZE(default_regions),
388                 .region_defs = default_regions,
389         },
390 };
391 
392 static const struct {
393         const char *file;
394         int compr_direction;
395         int num_caps;
396         const struct wm_adsp_fw_caps *caps;
397 } wm_adsp_fw[WM_ADSP_NUM_FW] = {
398         [WM_ADSP_FW_MBC_VSS] =  { .file = "mbc-vss" },
399         [WM_ADSP_FW_HIFI] =     { .file = "hifi" },
400         [WM_ADSP_FW_TX] =       { .file = "tx" },
401         [WM_ADSP_FW_TX_SPK] =   { .file = "tx-spk" },
402         [WM_ADSP_FW_RX] =       { .file = "rx" },
403         [WM_ADSP_FW_RX_ANC] =   { .file = "rx-anc" },
404         [WM_ADSP_FW_CTRL] =     {
405                 .file = "ctrl",
406                 .compr_direction = SND_COMPRESS_CAPTURE,
407                 .num_caps = ARRAY_SIZE(ctrl_caps),
408                 .caps = ctrl_caps,
409         },
410         [WM_ADSP_FW_ASR] =      { .file = "asr" },
411         [WM_ADSP_FW_TRACE] =    {
412                 .file = "trace",
413                 .compr_direction = SND_COMPRESS_CAPTURE,
414                 .num_caps = ARRAY_SIZE(trace_caps),
415                 .caps = trace_caps,
416         },
417         [WM_ADSP_FW_SPK_PROT] = { .file = "spk-prot" },
418         [WM_ADSP_FW_MISC] =     { .file = "misc" },
419 };
420 
421 struct wm_coeff_ctl_ops {
422         int (*xget)(struct snd_kcontrol *kcontrol,
423                     struct snd_ctl_elem_value *ucontrol);
424         int (*xput)(struct snd_kcontrol *kcontrol,
425                     struct snd_ctl_elem_value *ucontrol);
426         int (*xinfo)(struct snd_kcontrol *kcontrol,
427                      struct snd_ctl_elem_info *uinfo);
428 };
429 
430 struct wm_coeff_ctl {
431         const char *name;
432         const char *fw_name;
433         struct wm_adsp_alg_region alg_region;
434         struct wm_coeff_ctl_ops ops;
435         struct wm_adsp *dsp;
436         unsigned int enabled:1;
437         struct list_head list;
438         void *cache;
439         unsigned int offset;
440         size_t len;
441         unsigned int set:1;
442         struct snd_kcontrol *kcontrol;
443         struct soc_bytes_ext bytes_ext;
444         unsigned int flags;
445 };
446 
447 #ifdef CONFIG_DEBUG_FS
448 static void wm_adsp_debugfs_save_wmfwname(struct wm_adsp *dsp, const char *s)
449 {
450         char *tmp = kasprintf(GFP_KERNEL, "%s\n", s);
451 
452         kfree(dsp->wmfw_file_name);
453         dsp->wmfw_file_name = tmp;
454 }
455 
456 static void wm_adsp_debugfs_save_binname(struct wm_adsp *dsp, const char *s)
457 {
458         char *tmp = kasprintf(GFP_KERNEL, "%s\n", s);
459 
460         kfree(dsp->bin_file_name);
461         dsp->bin_file_name = tmp;
462 }
463 
464 static void wm_adsp_debugfs_clear(struct wm_adsp *dsp)
465 {
466         kfree(dsp->wmfw_file_name);
467         kfree(dsp->bin_file_name);
468         dsp->wmfw_file_name = NULL;
469         dsp->bin_file_name = NULL;
470 }
471 
472 static ssize_t wm_adsp_debugfs_wmfw_read(struct file *file,
473                                          char __user *user_buf,
474                                          size_t count, loff_t *ppos)
475 {
476         struct wm_adsp *dsp = file->private_data;
477         ssize_t ret;
478 
479         mutex_lock(&dsp->pwr_lock);
480 
481         if (!dsp->wmfw_file_name || !dsp->running)
482                 ret = 0;
483         else
484                 ret = simple_read_from_buffer(user_buf, count, ppos,
485                                               dsp->wmfw_file_name,
486                                               strlen(dsp->wmfw_file_name));
487 
488         mutex_unlock(&dsp->pwr_lock);
489         return ret;
490 }
491 
492 static ssize_t wm_adsp_debugfs_bin_read(struct file *file,
493                                         char __user *user_buf,
494                                         size_t count, loff_t *ppos)
495 {
496         struct wm_adsp *dsp = file->private_data;
497         ssize_t ret;
498 
499         mutex_lock(&dsp->pwr_lock);
500 
501         if (!dsp->bin_file_name || !dsp->running)
502                 ret = 0;
503         else
504                 ret = simple_read_from_buffer(user_buf, count, ppos,
505                                               dsp->bin_file_name,
506                                               strlen(dsp->bin_file_name));
507 
508         mutex_unlock(&dsp->pwr_lock);
509         return ret;
510 }
511 
512 static const struct {
513         const char *name;
514         const struct file_operations fops;
515 } wm_adsp_debugfs_fops[] = {
516         {
517                 .name = "wmfw_file_name",
518                 .fops = {
519                         .open = simple_open,
520                         .read = wm_adsp_debugfs_wmfw_read,
521                 },
522         },
523         {
524                 .name = "bin_file_name",
525                 .fops = {
526                         .open = simple_open,
527                         .read = wm_adsp_debugfs_bin_read,
528                 },
529         },
530 };
531 
532 static void wm_adsp2_init_debugfs(struct wm_adsp *dsp,
533                                   struct snd_soc_codec *codec)
534 {
535         struct dentry *root = NULL;
536         char *root_name;
537         int i;
538 
539         if (!codec->component.debugfs_root) {
540                 adsp_err(dsp, "No codec debugfs root\n");
541                 goto err;
542         }
543 
544         root_name = kmalloc(PAGE_SIZE, GFP_KERNEL);
545         if (!root_name)
546                 goto err;
547 
548         snprintf(root_name, PAGE_SIZE, "dsp%d", dsp->num);
549         root = debugfs_create_dir(root_name, codec->component.debugfs_root);
550         kfree(root_name);
551 
552         if (!root)
553                 goto err;
554 
555         if (!debugfs_create_bool("running", S_IRUGO, root, &dsp->running))
556                 goto err;
557 
558         if (!debugfs_create_x32("fw_id", S_IRUGO, root, &dsp->fw_id))
559                 goto err;
560 
561         if (!debugfs_create_x32("fw_version", S_IRUGO, root,
562                                 &dsp->fw_id_version))
563                 goto err;
564 
565         for (i = 0; i < ARRAY_SIZE(wm_adsp_debugfs_fops); ++i) {
566                 if (!debugfs_create_file(wm_adsp_debugfs_fops[i].name,
567                                          S_IRUGO, root, dsp,
568                                          &wm_adsp_debugfs_fops[i].fops))
569                         goto err;
570         }
571 
572         dsp->debugfs_root = root;
573         return;
574 
575 err:
576         debugfs_remove_recursive(root);
577         adsp_err(dsp, "Failed to create debugfs\n");
578 }
579 
580 static void wm_adsp2_cleanup_debugfs(struct wm_adsp *dsp)
581 {
582         wm_adsp_debugfs_clear(dsp);
583         debugfs_remove_recursive(dsp->debugfs_root);
584 }
585 #else
586 static inline void wm_adsp2_init_debugfs(struct wm_adsp *dsp,
587                                          struct snd_soc_codec *codec)
588 {
589 }
590 
591 static inline void wm_adsp2_cleanup_debugfs(struct wm_adsp *dsp)
592 {
593 }
594 
595 static inline void wm_adsp_debugfs_save_wmfwname(struct wm_adsp *dsp,
596                                                  const char *s)
597 {
598 }
599 
600 static inline void wm_adsp_debugfs_save_binname(struct wm_adsp *dsp,
601                                                 const char *s)
602 {
603 }
604 
605 static inline void wm_adsp_debugfs_clear(struct wm_adsp *dsp)
606 {
607 }
608 #endif
609 
610 static int wm_adsp_fw_get(struct snd_kcontrol *kcontrol,
611                           struct snd_ctl_elem_value *ucontrol)
612 {
613         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
614         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
615         struct wm_adsp *dsp = snd_soc_codec_get_drvdata(codec);
616 
617         ucontrol->value.enumerated.item[0] = dsp[e->shift_l].fw;
618 
619         return 0;
620 }
621 
622 static int wm_adsp_fw_put(struct snd_kcontrol *kcontrol,
623                           struct snd_ctl_elem_value *ucontrol)
624 {
625         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
626         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
627         struct wm_adsp *dsp = snd_soc_codec_get_drvdata(codec);
628         int ret = 0;
629 
630         if (ucontrol->value.enumerated.item[0] == dsp[e->shift_l].fw)
631                 return 0;
632 
633         if (ucontrol->value.enumerated.item[0] >= WM_ADSP_NUM_FW)
634                 return -EINVAL;
635 
636         mutex_lock(&dsp[e->shift_l].pwr_lock);
637 
638         if (dsp[e->shift_l].running || dsp[e->shift_l].compr)
639                 ret = -EBUSY;
640         else
641                 dsp[e->shift_l].fw = ucontrol->value.enumerated.item[0];
642 
643         mutex_unlock(&dsp[e->shift_l].pwr_lock);
644 
645         return ret;
646 }
647 
648 static const struct soc_enum wm_adsp_fw_enum[] = {
649         SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
650         SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
651         SOC_ENUM_SINGLE(0, 2, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
652         SOC_ENUM_SINGLE(0, 3, ARRAY_SIZE(wm_adsp_fw_text), wm_adsp_fw_text),
653 };
654 
655 const struct snd_kcontrol_new wm_adsp_fw_controls[] = {
656         SOC_ENUM_EXT("DSP1 Firmware", wm_adsp_fw_enum[0],
657                      wm_adsp_fw_get, wm_adsp_fw_put),
658         SOC_ENUM_EXT("DSP2 Firmware", wm_adsp_fw_enum[1],
659                      wm_adsp_fw_get, wm_adsp_fw_put),
660         SOC_ENUM_EXT("DSP3 Firmware", wm_adsp_fw_enum[2],
661                      wm_adsp_fw_get, wm_adsp_fw_put),
662         SOC_ENUM_EXT("DSP4 Firmware", wm_adsp_fw_enum[3],
663                      wm_adsp_fw_get, wm_adsp_fw_put),
664 };
665 EXPORT_SYMBOL_GPL(wm_adsp_fw_controls);
666 
667 static struct wm_adsp_region const *wm_adsp_find_region(struct wm_adsp *dsp,
668                                                         int type)
669 {
670         int i;
671 
672         for (i = 0; i < dsp->num_mems; i++)
673                 if (dsp->mem[i].type == type)
674                         return &dsp->mem[i];
675 
676         return NULL;
677 }
678 
679 static unsigned int wm_adsp_region_to_reg(struct wm_adsp_region const *mem,
680                                           unsigned int offset)
681 {
682         if (WARN_ON(!mem))
683                 return offset;
684         switch (mem->type) {
685         case WMFW_ADSP1_PM:
686                 return mem->base + (offset * 3);
687         case WMFW_ADSP1_DM:
688                 return mem->base + (offset * 2);
689         case WMFW_ADSP2_XM:
690                 return mem->base + (offset * 2);
691         case WMFW_ADSP2_YM:
692                 return mem->base + (offset * 2);
693         case WMFW_ADSP1_ZM:
694                 return mem->base + (offset * 2);
695         default:
696                 WARN(1, "Unknown memory region type");
697                 return offset;
698         }
699 }
700 
701 static void wm_adsp2_show_fw_status(struct wm_adsp *dsp)
702 {
703         u16 scratch[4];
704         int ret;
705 
706         ret = regmap_raw_read(dsp->regmap, dsp->base + ADSP2_SCRATCH0,
707                                 scratch, sizeof(scratch));
708         if (ret) {
709                 adsp_err(dsp, "Failed to read SCRATCH regs: %d\n", ret);
710                 return;
711         }
712 
713         adsp_dbg(dsp, "FW SCRATCH 0:0x%x 1:0x%x 2:0x%x 3:0x%x\n",
714                  be16_to_cpu(scratch[0]),
715                  be16_to_cpu(scratch[1]),
716                  be16_to_cpu(scratch[2]),
717                  be16_to_cpu(scratch[3]));
718 }
719 
720 static inline struct wm_coeff_ctl *bytes_ext_to_ctl(struct soc_bytes_ext *ext)
721 {
722         return container_of(ext, struct wm_coeff_ctl, bytes_ext);
723 }
724 
725 static int wm_coeff_info(struct snd_kcontrol *kctl,
726                          struct snd_ctl_elem_info *uinfo)
727 {
728         struct soc_bytes_ext *bytes_ext =
729                 (struct soc_bytes_ext *)kctl->private_value;
730         struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
731 
732         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
733         uinfo->count = ctl->len;
734         return 0;
735 }
736 
737 static int wm_coeff_write_control(struct wm_coeff_ctl *ctl,
738                                   const void *buf, size_t len)
739 {
740         struct wm_adsp_alg_region *alg_region = &ctl->alg_region;
741         const struct wm_adsp_region *mem;
742         struct wm_adsp *dsp = ctl->dsp;
743         void *scratch;
744         int ret;
745         unsigned int reg;
746 
747         mem = wm_adsp_find_region(dsp, alg_region->type);
748         if (!mem) {
749                 adsp_err(dsp, "No base for region %x\n",
750                          alg_region->type);
751                 return -EINVAL;
752         }
753 
754         reg = ctl->alg_region.base + ctl->offset;
755         reg = wm_adsp_region_to_reg(mem, reg);
756 
757         scratch = kmemdup(buf, len, GFP_KERNEL | GFP_DMA);
758         if (!scratch)
759                 return -ENOMEM;
760 
761         ret = regmap_raw_write(dsp->regmap, reg, scratch,
762                                len);
763         if (ret) {
764                 adsp_err(dsp, "Failed to write %zu bytes to %x: %d\n",
765                          len, reg, ret);
766                 kfree(scratch);
767                 return ret;
768         }
769         adsp_dbg(dsp, "Wrote %zu bytes to %x\n", len, reg);
770 
771         kfree(scratch);
772 
773         return 0;
774 }
775 
776 static int wm_coeff_put(struct snd_kcontrol *kctl,
777                         struct snd_ctl_elem_value *ucontrol)
778 {
779         struct soc_bytes_ext *bytes_ext =
780                 (struct soc_bytes_ext *)kctl->private_value;
781         struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
782         char *p = ucontrol->value.bytes.data;
783         int ret = 0;
784 
785         mutex_lock(&ctl->dsp->pwr_lock);
786 
787         memcpy(ctl->cache, p, ctl->len);
788 
789         ctl->set = 1;
790         if (ctl->enabled)
791                 ret = wm_coeff_write_control(ctl, p, ctl->len);
792 
793         mutex_unlock(&ctl->dsp->pwr_lock);
794 
795         return ret;
796 }
797 
798 static int wm_coeff_tlv_put(struct snd_kcontrol *kctl,
799                             const unsigned int __user *bytes, unsigned int size)
800 {
801         struct soc_bytes_ext *bytes_ext =
802                 (struct soc_bytes_ext *)kctl->private_value;
803         struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
804         int ret = 0;
805 
806         mutex_lock(&ctl->dsp->pwr_lock);
807 
808         if (copy_from_user(ctl->cache, bytes, size)) {
809                 ret = -EFAULT;
810         } else {
811                 ctl->set = 1;
812                 if (ctl->enabled)
813                         ret = wm_coeff_write_control(ctl, ctl->cache, size);
814         }
815 
816         mutex_unlock(&ctl->dsp->pwr_lock);
817 
818         return ret;
819 }
820 
821 static int wm_coeff_read_control(struct wm_coeff_ctl *ctl,
822                                  void *buf, size_t len)
823 {
824         struct wm_adsp_alg_region *alg_region = &ctl->alg_region;
825         const struct wm_adsp_region *mem;
826         struct wm_adsp *dsp = ctl->dsp;
827         void *scratch;
828         int ret;
829         unsigned int reg;
830 
831         mem = wm_adsp_find_region(dsp, alg_region->type);
832         if (!mem) {
833                 adsp_err(dsp, "No base for region %x\n",
834                          alg_region->type);
835                 return -EINVAL;
836         }
837 
838         reg = ctl->alg_region.base + ctl->offset;
839         reg = wm_adsp_region_to_reg(mem, reg);
840 
841         scratch = kmalloc(len, GFP_KERNEL | GFP_DMA);
842         if (!scratch)
843                 return -ENOMEM;
844 
845         ret = regmap_raw_read(dsp->regmap, reg, scratch, len);
846         if (ret) {
847                 adsp_err(dsp, "Failed to read %zu bytes from %x: %d\n",
848                          len, reg, ret);
849                 kfree(scratch);
850                 return ret;
851         }
852         adsp_dbg(dsp, "Read %zu bytes from %x\n", len, reg);
853 
854         memcpy(buf, scratch, len);
855         kfree(scratch);
856 
857         return 0;
858 }
859 
860 static int wm_coeff_get(struct snd_kcontrol *kctl,
861                         struct snd_ctl_elem_value *ucontrol)
862 {
863         struct soc_bytes_ext *bytes_ext =
864                 (struct soc_bytes_ext *)kctl->private_value;
865         struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
866         char *p = ucontrol->value.bytes.data;
867         int ret = 0;
868 
869         mutex_lock(&ctl->dsp->pwr_lock);
870 
871         if (ctl->flags & WMFW_CTL_FLAG_VOLATILE) {
872                 if (ctl->enabled)
873                         ret = wm_coeff_read_control(ctl, p, ctl->len);
874                 else
875                         ret = -EPERM;
876         } else {
877                 if (!ctl->flags && ctl->enabled)
878                         ret = wm_coeff_read_control(ctl, ctl->cache, ctl->len);
879 
880                 memcpy(p, ctl->cache, ctl->len);
881         }
882 
883         mutex_unlock(&ctl->dsp->pwr_lock);
884 
885         return ret;
886 }
887 
888 static int wm_coeff_tlv_get(struct snd_kcontrol *kctl,
889                             unsigned int __user *bytes, unsigned int size)
890 {
891         struct soc_bytes_ext *bytes_ext =
892                 (struct soc_bytes_ext *)kctl->private_value;
893         struct wm_coeff_ctl *ctl = bytes_ext_to_ctl(bytes_ext);
894         int ret = 0;
895 
896         mutex_lock(&ctl->dsp->pwr_lock);
897 
898         if (ctl->flags & WMFW_CTL_FLAG_VOLATILE) {
899                 if (ctl->enabled)
900                         ret = wm_coeff_read_control(ctl, ctl->cache, size);
901                 else
902                         ret = -EPERM;
903         } else {
904                 if (!ctl->flags && ctl->enabled)
905                         ret = wm_coeff_read_control(ctl, ctl->cache, size);
906         }
907 
908         if (!ret && copy_to_user(bytes, ctl->cache, size))
909                 ret = -EFAULT;
910 
911         mutex_unlock(&ctl->dsp->pwr_lock);
912 
913         return ret;
914 }
915 
916 struct wmfw_ctl_work {
917         struct wm_adsp *dsp;
918         struct wm_coeff_ctl *ctl;
919         struct work_struct work;
920 };
921 
922 static unsigned int wmfw_convert_flags(unsigned int in, unsigned int len)
923 {
924         unsigned int out, rd, wr, vol;
925 
926         if (len > ADSP_MAX_STD_CTRL_SIZE) {
927                 rd = SNDRV_CTL_ELEM_ACCESS_TLV_READ;
928                 wr = SNDRV_CTL_ELEM_ACCESS_TLV_WRITE;
929                 vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;
930 
931                 out = SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
932         } else {
933                 rd = SNDRV_CTL_ELEM_ACCESS_READ;
934                 wr = SNDRV_CTL_ELEM_ACCESS_WRITE;
935                 vol = SNDRV_CTL_ELEM_ACCESS_VOLATILE;
936 
937                 out = 0;
938         }
939 
940         if (in) {
941                 if (in & WMFW_CTL_FLAG_READABLE)
942                         out |= rd;
943                 if (in & WMFW_CTL_FLAG_WRITEABLE)
944                         out |= wr;
945                 if (in & WMFW_CTL_FLAG_VOLATILE)
946                         out |= vol;
947         } else {
948                 out |= rd | wr | vol;
949         }
950 
951         return out;
952 }
953 
954 static int wmfw_add_ctl(struct wm_adsp *dsp, struct wm_coeff_ctl *ctl)
955 {
956         struct snd_kcontrol_new *kcontrol;
957         int ret;
958 
959         if (!ctl || !ctl->name)
960                 return -EINVAL;
961 
962         kcontrol = kzalloc(sizeof(*kcontrol), GFP_KERNEL);
963         if (!kcontrol)
964                 return -ENOMEM;
965         kcontrol->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
966 
967         kcontrol->name = ctl->name;
968         kcontrol->info = wm_coeff_info;
969         kcontrol->get = wm_coeff_get;
970         kcontrol->put = wm_coeff_put;
971         kcontrol->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
972         kcontrol->tlv.c = snd_soc_bytes_tlv_callback;
973         kcontrol->private_value = (unsigned long)&ctl->bytes_ext;
974 
975         ctl->bytes_ext.max = ctl->len;
976         ctl->bytes_ext.get = wm_coeff_tlv_get;
977         ctl->bytes_ext.put = wm_coeff_tlv_put;
978 
979         kcontrol->access = wmfw_convert_flags(ctl->flags, ctl->len);
980 
981         ret = snd_soc_add_card_controls(dsp->card, kcontrol, 1);
982         if (ret < 0)
983                 goto err_kcontrol;
984 
985         kfree(kcontrol);
986 
987         ctl->kcontrol = snd_soc_card_get_kcontrol(dsp->card, ctl->name);
988 
989         return 0;
990 
991 err_kcontrol:
992         kfree(kcontrol);
993         return ret;
994 }
995 
996 static int wm_coeff_init_control_caches(struct wm_adsp *dsp)
997 {
998         struct wm_coeff_ctl *ctl;
999         int ret;
1000 
1001         list_for_each_entry(ctl, &dsp->ctl_list, list) {
1002                 if (!ctl->enabled || ctl->set)
1003                         continue;
1004                 if (ctl->flags & WMFW_CTL_FLAG_VOLATILE)
1005                         continue;
1006 
1007                 ret = wm_coeff_read_control(ctl, ctl->cache, ctl->len);
1008                 if (ret < 0)
1009                         return ret;
1010         }
1011 
1012         return 0;
1013 }
1014 
1015 static int wm_coeff_sync_controls(struct wm_adsp *dsp)
1016 {
1017         struct wm_coeff_ctl *ctl;
1018         int ret;
1019 
1020         list_for_each_entry(ctl, &dsp->ctl_list, list) {
1021                 if (!ctl->enabled)
1022                         continue;
1023                 if (ctl->set && !(ctl->flags & WMFW_CTL_FLAG_VOLATILE)) {
1024                         ret = wm_coeff_write_control(ctl, ctl->cache, ctl->len);
1025                         if (ret < 0)
1026                                 return ret;
1027                 }
1028         }
1029 
1030         return 0;
1031 }
1032 
1033 static void wm_adsp_ctl_work(struct work_struct *work)
1034 {
1035         struct wmfw_ctl_work *ctl_work = container_of(work,
1036                                                       struct wmfw_ctl_work,
1037                                                       work);
1038 
1039         wmfw_add_ctl(ctl_work->dsp, ctl_work->ctl);
1040         kfree(ctl_work);
1041 }
1042 
1043 static void wm_adsp_free_ctl_blk(struct wm_coeff_ctl *ctl)
1044 {
1045         kfree(ctl->cache);
1046         kfree(ctl->name);
1047         kfree(ctl);
1048 }
1049 
1050 static int wm_adsp_create_control(struct wm_adsp *dsp,
1051                                   const struct wm_adsp_alg_region *alg_region,
1052                                   unsigned int offset, unsigned int len,
1053                                   const char *subname, unsigned int subname_len,
1054                                   unsigned int flags)
1055 {
1056         struct wm_coeff_ctl *ctl;
1057         struct wmfw_ctl_work *ctl_work;
1058         char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1059         char *region_name;
1060         int ret;
1061 
1062         if (flags & WMFW_CTL_FLAG_SYS)
1063                 return 0;
1064 
1065         switch (alg_region->type) {
1066         case WMFW_ADSP1_PM:
1067                 region_name = "PM";
1068                 break;
1069         case WMFW_ADSP1_DM:
1070                 region_name = "DM";
1071                 break;
1072         case WMFW_ADSP2_XM:
1073                 region_name = "XM";
1074                 break;
1075         case WMFW_ADSP2_YM:
1076                 region_name = "YM";
1077                 break;
1078         case WMFW_ADSP1_ZM:
1079                 region_name = "ZM";
1080                 break;
1081         default:
1082                 adsp_err(dsp, "Unknown region type: %d\n", alg_region->type);
1083                 return -EINVAL;
1084         }
1085 
1086         switch (dsp->fw_ver) {
1087         case 0:
1088         case 1:
1089                 snprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "DSP%d %s %x",
1090                          dsp->num, region_name, alg_region->alg);
1091                 break;
1092         default:
1093                 ret = snprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN,
1094                                 "DSP%d%c %.12s %x", dsp->num, *region_name,
1095                                 wm_adsp_fw_text[dsp->fw], alg_region->alg);
1096 
1097                 /* Truncate the subname from the start if it is too long */
1098                 if (subname) {
1099                         int avail = SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret - 2;
1100                         int skip = 0;
1101 
1102                         if (subname_len > avail)
1103                                 skip = subname_len - avail;
1104 
1105                         snprintf(name + ret,
1106                                  SNDRV_CTL_ELEM_ID_NAME_MAXLEN - ret, " %.*s",
1107                                  subname_len - skip, subname + skip);
1108                 }
1109                 break;
1110         }
1111 
1112         list_for_each_entry(ctl, &dsp->ctl_list, list) {
1113                 if (!strcmp(ctl->name, name)) {
1114                         if (!ctl->enabled)
1115                                 ctl->enabled = 1;
1116                         return 0;
1117                 }
1118         }
1119 
1120         ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
1121         if (!ctl)
1122                 return -ENOMEM;
1123         ctl->fw_name = wm_adsp_fw_text[dsp->fw];
1124         ctl->alg_region = *alg_region;
1125         ctl->name = kmemdup(name, strlen(name) + 1, GFP_KERNEL);
1126         if (!ctl->name) {
1127                 ret = -ENOMEM;
1128                 goto err_ctl;
1129         }
1130         ctl->enabled = 1;
1131         ctl->set = 0;
1132         ctl->ops.xget = wm_coeff_get;
1133         ctl->ops.xput = wm_coeff_put;
1134         ctl->dsp = dsp;
1135 
1136         ctl->flags = flags;
1137         ctl->offset = offset;
1138         ctl->len = len;
1139         ctl->cache = kzalloc(ctl->len, GFP_KERNEL);
1140         if (!ctl->cache) {
1141                 ret = -ENOMEM;
1142                 goto err_ctl_name;
1143         }
1144 
1145         list_add(&ctl->list, &dsp->ctl_list);
1146 
1147         ctl_work = kzalloc(sizeof(*ctl_work), GFP_KERNEL);
1148         if (!ctl_work) {
1149                 ret = -ENOMEM;
1150                 goto err_ctl_cache;
1151         }
1152 
1153         ctl_work->dsp = dsp;
1154         ctl_work->ctl = ctl;
1155         INIT_WORK(&ctl_work->work, wm_adsp_ctl_work);
1156         schedule_work(&ctl_work->work);
1157 
1158         return 0;
1159 
1160 err_ctl_cache:
1161         kfree(ctl->cache);
1162 err_ctl_name:
1163         kfree(ctl->name);
1164 err_ctl:
1165         kfree(ctl);
1166 
1167         return ret;
1168 }
1169 
1170 struct wm_coeff_parsed_alg {
1171         int id;
1172         const u8 *name;
1173         int name_len;
1174         int ncoeff;
1175 };
1176 
1177 struct wm_coeff_parsed_coeff {
1178         int offset;
1179         int mem_type;
1180         const u8 *name;
1181         int name_len;
1182         int ctl_type;
1183         int flags;
1184         int len;
1185 };
1186 
1187 static int wm_coeff_parse_string(int bytes, const u8 **pos, const u8 **str)
1188 {
1189         int length;
1190 
1191         switch (bytes) {
1192         case 1:
1193                 length = **pos;
1194                 break;
1195         case 2:
1196                 length = le16_to_cpu(*((__le16 *)*pos));
1197                 break;
1198         default:
1199                 return 0;
1200         }
1201 
1202         if (str)
1203                 *str = *pos + bytes;
1204 
1205         *pos += ((length + bytes) + 3) & ~0x03;
1206 
1207         return length;
1208 }
1209 
1210 static int wm_coeff_parse_int(int bytes, const u8 **pos)
1211 {
1212         int val = 0;
1213 
1214         switch (bytes) {
1215         case 2:
1216                 val = le16_to_cpu(*((__le16 *)*pos));
1217                 break;
1218         case 4:
1219                 val = le32_to_cpu(*((__le32 *)*pos));
1220                 break;
1221         default:
1222                 break;
1223         }
1224 
1225         *pos += bytes;
1226 
1227         return val;
1228 }
1229 
1230 static inline void wm_coeff_parse_alg(struct wm_adsp *dsp, const u8 **data,
1231                                       struct wm_coeff_parsed_alg *blk)
1232 {
1233         const struct wmfw_adsp_alg_data *raw;
1234 
1235         switch (dsp->fw_ver) {
1236         case 0:
1237         case 1:
1238                 raw = (const struct wmfw_adsp_alg_data *)*data;
1239                 *data = raw->data;
1240 
1241                 blk->id = le32_to_cpu(raw->id);
1242                 blk->name = raw->name;
1243                 blk->name_len = strlen(raw->name);
1244                 blk->ncoeff = le32_to_cpu(raw->ncoeff);
1245                 break;
1246         default:
1247                 blk->id = wm_coeff_parse_int(sizeof(raw->id), data);
1248                 blk->name_len = wm_coeff_parse_string(sizeof(u8), data,
1249                                                       &blk->name);
1250                 wm_coeff_parse_string(sizeof(u16), data, NULL);
1251                 blk->ncoeff = wm_coeff_parse_int(sizeof(raw->ncoeff), data);
1252                 break;
1253         }
1254 
1255         adsp_dbg(dsp, "Algorithm ID: %#x\n", blk->id);
1256         adsp_dbg(dsp, "Algorithm name: %.*s\n", blk->name_len, blk->name);
1257         adsp_dbg(dsp, "# of coefficient descriptors: %#x\n", blk->ncoeff);
1258 }
1259 
1260 static inline void wm_coeff_parse_coeff(struct wm_adsp *dsp, const u8 **data,
1261                                         struct wm_coeff_parsed_coeff *blk)
1262 {
1263         const struct wmfw_adsp_coeff_data *raw;
1264         const u8 *tmp;
1265         int length;
1266 
1267         switch (dsp->fw_ver) {
1268         case 0:
1269         case 1:
1270                 raw = (const struct wmfw_adsp_coeff_data *)*data;
1271                 *data = *data + sizeof(raw->hdr) + le32_to_cpu(raw->hdr.size);
1272 
1273                 blk->offset = le16_to_cpu(raw->hdr.offset);
1274                 blk->mem_type = le16_to_cpu(raw->hdr.type);
1275                 blk->name = raw->name;
1276                 blk->name_len = strlen(raw->name);
1277                 blk->ctl_type = le16_to_cpu(raw->ctl_type);
1278                 blk->flags = le16_to_cpu(raw->flags);
1279                 blk->len = le32_to_cpu(raw->len);
1280                 break;
1281         default:
1282                 tmp = *data;
1283                 blk->offset = wm_coeff_parse_int(sizeof(raw->hdr.offset), &tmp);
1284                 blk->mem_type = wm_coeff_parse_int(sizeof(raw->hdr.type), &tmp);
1285                 length = wm_coeff_parse_int(sizeof(raw->hdr.size), &tmp);
1286                 blk->name_len = wm_coeff_parse_string(sizeof(u8), &tmp,
1287                                                       &blk->name);
1288                 wm_coeff_parse_string(sizeof(u8), &tmp, NULL);
1289                 wm_coeff_parse_string(sizeof(u16), &tmp, NULL);
1290                 blk->ctl_type = wm_coeff_parse_int(sizeof(raw->ctl_type), &tmp);
1291                 blk->flags = wm_coeff_parse_int(sizeof(raw->flags), &tmp);
1292                 blk->len = wm_coeff_parse_int(sizeof(raw->len), &tmp);
1293 
1294                 *data = *data + sizeof(raw->hdr) + length;
1295                 break;
1296         }
1297 
1298         adsp_dbg(dsp, "\tCoefficient type: %#x\n", blk->mem_type);
1299         adsp_dbg(dsp, "\tCoefficient offset: %#x\n", blk->offset);
1300         adsp_dbg(dsp, "\tCoefficient name: %.*s\n", blk->name_len, blk->name);
1301         adsp_dbg(dsp, "\tCoefficient flags: %#x\n", blk->flags);
1302         adsp_dbg(dsp, "\tALSA control type: %#x\n", blk->ctl_type);
1303         adsp_dbg(dsp, "\tALSA control len: %#x\n", blk->len);
1304 }
1305 
1306 static int wm_adsp_parse_coeff(struct wm_adsp *dsp,
1307                                const struct wmfw_region *region)
1308 {
1309         struct wm_adsp_alg_region alg_region = {};
1310         struct wm_coeff_parsed_alg alg_blk;
1311         struct wm_coeff_parsed_coeff coeff_blk;
1312         const u8 *data = region->data;
1313         int i, ret;
1314 
1315         wm_coeff_parse_alg(dsp, &data, &alg_blk);
1316         for (i = 0; i < alg_blk.ncoeff; i++) {
1317                 wm_coeff_parse_coeff(dsp, &data, &coeff_blk);
1318 
1319                 switch (coeff_blk.ctl_type) {
1320                 case SNDRV_CTL_ELEM_TYPE_BYTES:
1321                         break;
1322                 default:
1323                         adsp_err(dsp, "Unknown control type: %d\n",
1324                                  coeff_blk.ctl_type);
1325                         return -EINVAL;
1326                 }
1327 
1328                 alg_region.type = coeff_blk.mem_type;
1329                 alg_region.alg = alg_blk.id;
1330 
1331                 ret = wm_adsp_create_control(dsp, &alg_region,
1332                                              coeff_blk.offset,
1333                                              coeff_blk.len,
1334                                              coeff_blk.name,
1335                                              coeff_blk.name_len,
1336                                              coeff_blk.flags);
1337                 if (ret < 0)
1338                         adsp_err(dsp, "Failed to create control: %.*s, %d\n",
1339                                  coeff_blk.name_len, coeff_blk.name, ret);
1340         }
1341 
1342         return 0;
1343 }
1344 
1345 static int wm_adsp_load(struct wm_adsp *dsp)
1346 {
1347         LIST_HEAD(buf_list);
1348         const struct firmware *firmware;
1349         struct regmap *regmap = dsp->regmap;
1350         unsigned int pos = 0;
1351         const struct wmfw_header *header;
1352         const struct wmfw_adsp1_sizes *adsp1_sizes;
1353         const struct wmfw_adsp2_sizes *adsp2_sizes;
1354         const struct wmfw_footer *footer;
1355         const struct wmfw_region *region;
1356         const struct wm_adsp_region *mem;
1357         const char *region_name;
1358         char *file, *text;
1359         struct wm_adsp_buf *buf;
1360         unsigned int reg;
1361         int regions = 0;
1362         int ret, offset, type, sizes;
1363 
1364         file = kzalloc(PAGE_SIZE, GFP_KERNEL);
1365         if (file == NULL)
1366                 return -ENOMEM;
1367 
1368         snprintf(file, PAGE_SIZE, "%s-dsp%d-%s.wmfw", dsp->part, dsp->num,
1369                  wm_adsp_fw[dsp->fw].file);
1370         file[PAGE_SIZE - 1] = '\0';
1371 
1372         ret = request_firmware(&firmware, file, dsp->dev);
1373         if (ret != 0) {
1374                 adsp_err(dsp, "Failed to request '%s'\n", file);
1375                 goto out;
1376         }
1377         ret = -EINVAL;
1378 
1379         pos = sizeof(*header) + sizeof(*adsp1_sizes) + sizeof(*footer);
1380         if (pos >= firmware->size) {
1381                 adsp_err(dsp, "%s: file too short, %zu bytes\n",
1382                          file, firmware->size);
1383                 goto out_fw;
1384         }
1385 
1386         header = (void *)&firmware->data[0];
1387 
1388         if (memcmp(&header->magic[0], "WMFW", 4) != 0) {
1389                 adsp_err(dsp, "%s: invalid magic\n", file);
1390                 goto out_fw;
1391         }
1392 
1393         switch (header->ver) {
1394         case 0:
1395                 adsp_warn(dsp, "%s: Depreciated file format %d\n",
1396                           file, header->ver);
1397                 break;
1398         case 1:
1399         case 2:
1400                 break;
1401         default:
1402                 adsp_err(dsp, "%s: unknown file format %d\n",
1403                          file, header->ver);
1404                 goto out_fw;
1405         }
1406 
1407         adsp_info(dsp, "Firmware version: %d\n", header->ver);
1408         dsp->fw_ver = header->ver;
1409 
1410         if (header->core != dsp->type) {
1411                 adsp_err(dsp, "%s: invalid core %d != %d\n",
1412                          file, header->core, dsp->type);
1413                 goto out_fw;
1414         }
1415 
1416         switch (dsp->type) {
1417         case WMFW_ADSP1:
1418                 pos = sizeof(*header) + sizeof(*adsp1_sizes) + sizeof(*footer);
1419                 adsp1_sizes = (void *)&(header[1]);
1420                 footer = (void *)&(adsp1_sizes[1]);
1421                 sizes = sizeof(*adsp1_sizes);
1422 
1423                 adsp_dbg(dsp, "%s: %d DM, %d PM, %d ZM\n",
1424                          file, le32_to_cpu(adsp1_sizes->dm),
1425                          le32_to_cpu(adsp1_sizes->pm),
1426                          le32_to_cpu(adsp1_sizes->zm));
1427                 break;
1428 
1429         case WMFW_ADSP2:
1430                 pos = sizeof(*header) + sizeof(*adsp2_sizes) + sizeof(*footer);
1431                 adsp2_sizes = (void *)&(header[1]);
1432                 footer = (void *)&(adsp2_sizes[1]);
1433                 sizes = sizeof(*adsp2_sizes);
1434 
1435                 adsp_dbg(dsp, "%s: %d XM, %d YM %d PM, %d ZM\n",
1436                          file, le32_to_cpu(adsp2_sizes->xm),
1437                          le32_to_cpu(adsp2_sizes->ym),
1438                          le32_to_cpu(adsp2_sizes->pm),
1439                          le32_to_cpu(adsp2_sizes->zm));
1440                 break;
1441 
1442         default:
1443                 WARN(1, "Unknown DSP type");
1444                 goto out_fw;
1445         }
1446 
1447         if (le32_to_cpu(header->len) != sizeof(*header) +
1448             sizes + sizeof(*footer)) {
1449                 adsp_err(dsp, "%s: unexpected header length %d\n",
1450                          file, le32_to_cpu(header->len));
1451                 goto out_fw;
1452         }
1453 
1454         adsp_dbg(dsp, "%s: timestamp %llu\n", file,
1455                  le64_to_cpu(footer->timestamp));
1456 
1457         while (pos < firmware->size &&
1458                pos - firmware->size > sizeof(*region)) {
1459                 region = (void *)&(firmware->data[pos]);
1460                 region_name = "Unknown";
1461                 reg = 0;
1462                 text = NULL;
1463                 offset = le32_to_cpu(region->offset) & 0xffffff;
1464                 type = be32_to_cpu(region->type) & 0xff;
1465                 mem = wm_adsp_find_region(dsp, type);
1466 
1467                 switch (type) {
1468                 case WMFW_NAME_TEXT:
1469                         region_name = "Firmware name";
1470                         text = kzalloc(le32_to_cpu(region->len) + 1,
1471                                        GFP_KERNEL);
1472                         break;
1473                 case WMFW_ALGORITHM_DATA:
1474                         region_name = "Algorithm";
1475                         ret = wm_adsp_parse_coeff(dsp, region);
1476                         if (ret != 0)
1477                                 goto out_fw;
1478                         break;
1479                 case WMFW_INFO_TEXT:
1480                         region_name = "Information";
1481                         text = kzalloc(le32_to_cpu(region->len) + 1,
1482                                        GFP_KERNEL);
1483                         break;
1484                 case WMFW_ABSOLUTE:
1485                         region_name = "Absolute";
1486                         reg = offset;
1487                         break;
1488                 case WMFW_ADSP1_PM:
1489                         region_name = "PM";
1490                         reg = wm_adsp_region_to_reg(mem, offset);
1491                         break;
1492                 case WMFW_ADSP1_DM:
1493                         region_name = "DM";
1494                         reg = wm_adsp_region_to_reg(mem, offset);
1495                         break;
1496                 case WMFW_ADSP2_XM:
1497                         region_name = "XM";
1498                         reg = wm_adsp_region_to_reg(mem, offset);
1499                         break;
1500                 case WMFW_ADSP2_YM:
1501                         region_name = "YM";
1502                         reg = wm_adsp_region_to_reg(mem, offset);
1503                         break;
1504                 case WMFW_ADSP1_ZM:
1505                         region_name = "ZM";
1506                         reg = wm_adsp_region_to_reg(mem, offset);
1507                         break;
1508                 default:
1509                         adsp_warn(dsp,
1510                                   "%s.%d: Unknown region type %x at %d(%x)\n",
1511                                   file, regions, type, pos, pos);
1512                         break;
1513                 }
1514 
1515                 adsp_dbg(dsp, "%s.%d: %d bytes at %d in %s\n", file,
1516                          regions, le32_to_cpu(region->len), offset,
1517                          region_name);
1518 
1519                 if (text) {
1520                         memcpy(text, region->data, le32_to_cpu(region->len));
1521                         adsp_info(dsp, "%s: %s\n", file, text);
1522                         kfree(text);
1523                 }
1524 
1525                 if (reg) {
1526                         buf = wm_adsp_buf_alloc(region->data,
1527                                                 le32_to_cpu(region->len),
1528                                                 &buf_list);
1529                         if (!buf) {
1530                                 adsp_err(dsp, "Out of memory\n");
1531                                 ret = -ENOMEM;
1532                                 goto out_fw;
1533                         }
1534 
1535                         ret = regmap_raw_write_async(regmap, reg, buf->buf,
1536                                                      le32_to_cpu(region->len));
1537                         if (ret != 0) {
1538                                 adsp_err(dsp,
1539                                         "%s.%d: Failed to write %d bytes at %d in %s: %d\n",
1540                                         file, regions,
1541                                         le32_to_cpu(region->len), offset,
1542                                         region_name, ret);
1543                                 goto out_fw;
1544                         }
1545                 }
1546 
1547                 pos += le32_to_cpu(region->len) + sizeof(*region);
1548                 regions++;
1549         }
1550 
1551         ret = regmap_async_complete(regmap);
1552         if (ret != 0) {
1553                 adsp_err(dsp, "Failed to complete async write: %d\n", ret);
1554                 goto out_fw;
1555         }
1556 
1557         if (pos > firmware->size)
1558                 adsp_warn(dsp, "%s.%d: %zu bytes at end of file\n",
1559                           file, regions, pos - firmware->size);
1560 
1561         wm_adsp_debugfs_save_wmfwname(dsp, file);
1562 
1563 out_fw:
1564         regmap_async_complete(regmap);
1565         wm_adsp_buf_free(&buf_list);
1566         release_firmware(firmware);
1567 out:
1568         kfree(file);
1569 
1570         return ret;
1571 }
1572 
1573 static void wm_adsp_ctl_fixup_base(struct wm_adsp *dsp,
1574                                   const struct wm_adsp_alg_region *alg_region)
1575 {
1576         struct wm_coeff_ctl *ctl;
1577 
1578         list_for_each_entry(ctl, &dsp->ctl_list, list) {
1579                 if (ctl->fw_name == wm_adsp_fw_text[dsp->fw] &&
1580                     alg_region->alg == ctl->alg_region.alg &&
1581                     alg_region->type == ctl->alg_region.type) {
1582                         ctl->alg_region.base = alg_region->base;
1583                 }
1584         }
1585 }
1586 
1587 static void *wm_adsp_read_algs(struct wm_adsp *dsp, size_t n_algs,
1588                                unsigned int pos, unsigned int len)
1589 {
1590         void *alg;
1591         int ret;
1592         __be32 val;
1593 
1594         if (n_algs == 0) {
1595                 adsp_err(dsp, "No algorithms\n");
1596                 return ERR_PTR(-EINVAL);
1597         }
1598 
1599         if (n_algs > 1024) {
1600                 adsp_err(dsp, "Algorithm count %zx excessive\n", n_algs);
1601                 return ERR_PTR(-EINVAL);
1602         }
1603 
1604         /* Read the terminator first to validate the length */
1605         ret = regmap_raw_read(dsp->regmap, pos + len, &val, sizeof(val));
1606         if (ret != 0) {
1607                 adsp_err(dsp, "Failed to read algorithm list end: %d\n",
1608                         ret);
1609                 return ERR_PTR(ret);
1610         }
1611 
1612         if (be32_to_cpu(val) != 0xbedead)
1613                 adsp_warn(dsp, "Algorithm list end %x 0x%x != 0xbeadead\n",
1614                           pos + len, be32_to_cpu(val));
1615 
1616         alg = kzalloc(len * 2, GFP_KERNEL | GFP_DMA);
1617         if (!alg)
1618                 return ERR_PTR(-ENOMEM);
1619 
1620         ret = regmap_raw_read(dsp->regmap, pos, alg, len * 2);
1621         if (ret != 0) {
1622                 adsp_err(dsp, "Failed to read algorithm list: %d\n", ret);
1623                 kfree(alg);
1624                 return ERR_PTR(ret);
1625         }
1626 
1627         return alg;
1628 }
1629 
1630 static struct wm_adsp_alg_region *
1631         wm_adsp_find_alg_region(struct wm_adsp *dsp, int type, unsigned int id)
1632 {
1633         struct wm_adsp_alg_region *alg_region;
1634 
1635         list_for_each_entry(alg_region, &dsp->alg_regions, list) {
1636                 if (id == alg_region->alg && type == alg_region->type)
1637                         return alg_region;
1638         }
1639 
1640         return NULL;
1641 }
1642 
1643 static struct wm_adsp_alg_region *wm_adsp_create_region(struct wm_adsp *dsp,
1644                                                         int type, __be32 id,
1645                                                         __be32 base)
1646 {
1647         struct wm_adsp_alg_region *alg_region;
1648 
1649         alg_region = kzalloc(sizeof(*alg_region), GFP_KERNEL);
1650         if (!alg_region)
1651                 return ERR_PTR(-ENOMEM);
1652 
1653         alg_region->type = type;
1654         alg_region->alg = be32_to_cpu(id);
1655         alg_region->base = be32_to_cpu(base);
1656 
1657         list_add_tail(&alg_region->list, &dsp->alg_regions);
1658 
1659         if (dsp->fw_ver > 0)
1660                 wm_adsp_ctl_fixup_base(dsp, alg_region);
1661 
1662         return alg_region;
1663 }
1664 
1665 static void wm_adsp_free_alg_regions(struct wm_adsp *dsp)
1666 {
1667         struct wm_adsp_alg_region *alg_region;
1668 
1669         while (!list_empty(&dsp->alg_regions)) {
1670                 alg_region = list_first_entry(&dsp->alg_regions,
1671                                               struct wm_adsp_alg_region,
1672                                               list);
1673                 list_del(&alg_region->list);
1674                 kfree(alg_region);
1675         }
1676 }
1677 
1678 static int wm_adsp1_setup_algs(struct wm_adsp *dsp)
1679 {
1680         struct wmfw_adsp1_id_hdr adsp1_id;
1681         struct wmfw_adsp1_alg_hdr *adsp1_alg;
1682         struct wm_adsp_alg_region *alg_region;
1683         const struct wm_adsp_region *mem;
1684         unsigned int pos, len;
1685         size_t n_algs;
1686         int i, ret;
1687 
1688         mem = wm_adsp_find_region(dsp, WMFW_ADSP1_DM);
1689         if (WARN_ON(!mem))
1690                 return -EINVAL;
1691 
1692         ret = regmap_raw_read(dsp->regmap, mem->base, &adsp1_id,
1693                               sizeof(adsp1_id));
1694         if (ret != 0) {
1695                 adsp_err(dsp, "Failed to read algorithm info: %d\n",
1696                          ret);
1697                 return ret;
1698         }
1699 
1700         n_algs = be32_to_cpu(adsp1_id.n_algs);
1701         dsp->fw_id = be32_to_cpu(adsp1_id.fw.id);
1702         adsp_info(dsp, "Firmware: %x v%d.%d.%d, %zu algorithms\n",
1703                   dsp->fw_id,
1704                   (be32_to_cpu(adsp1_id.fw.ver) & 0xff0000) >> 16,
1705                   (be32_to_cpu(adsp1_id.fw.ver) & 0xff00) >> 8,
1706                   be32_to_cpu(adsp1_id.fw.ver) & 0xff,
1707                   n_algs);
1708 
1709         alg_region = wm_adsp_create_region(dsp, WMFW_ADSP1_ZM,
1710                                            adsp1_id.fw.id, adsp1_id.zm);
1711         if (IS_ERR(alg_region))
1712                 return PTR_ERR(alg_region);
1713 
1714         alg_region = wm_adsp_create_region(dsp, WMFW_ADSP1_DM,
1715                                            adsp1_id.fw.id, adsp1_id.dm);
1716         if (IS_ERR(alg_region))
1717                 return PTR_ERR(alg_region);
1718 
1719         pos = sizeof(adsp1_id) / 2;
1720         len = (sizeof(*adsp1_alg) * n_algs) / 2;
1721 
1722         adsp1_alg = wm_adsp_read_algs(dsp, n_algs, mem->base + pos, len);
1723         if (IS_ERR(adsp1_alg))
1724                 return PTR_ERR(adsp1_alg);
1725 
1726         for (i = 0; i < n_algs; i++) {
1727                 adsp_info(dsp, "%d: ID %x v%d.%d.%d DM@%x ZM@%x\n",
1728                           i, be32_to_cpu(adsp1_alg[i].alg.id),
1729                           (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff0000) >> 16,
1730                           (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff00) >> 8,
1731                           be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff,
1732                           be32_to_cpu(adsp1_alg[i].dm),
1733                           be32_to_cpu(adsp1_alg[i].zm));
1734 
1735                 alg_region = wm_adsp_create_region(dsp, WMFW_ADSP1_DM,
1736                                                    adsp1_alg[i].alg.id,
1737                                                    adsp1_alg[i].dm);
1738                 if (IS_ERR(alg_region)) {
1739                         ret = PTR_ERR(alg_region);
1740                         goto out;
1741                 }
1742                 if (dsp->fw_ver == 0) {
1743                         if (i + 1 < n_algs) {
1744                                 len = be32_to_cpu(adsp1_alg[i + 1].dm);
1745                                 len -= be32_to_cpu(adsp1_alg[i].dm);
1746                                 len *= 4;
1747                                 wm_adsp_create_control(dsp, alg_region, 0,
1748                                                        len, NULL, 0, 0);
1749                         } else {
1750                                 adsp_warn(dsp, "Missing length info for region DM with ID %x\n",
1751                                           be32_to_cpu(adsp1_alg[i].alg.id));
1752                         }
1753                 }
1754 
1755                 alg_region = wm_adsp_create_region(dsp, WMFW_ADSP1_ZM,
1756                                                    adsp1_alg[i].alg.id,
1757                                                    adsp1_alg[i].zm);
1758                 if (IS_ERR(alg_region)) {
1759                         ret = PTR_ERR(alg_region);
1760                         goto out;
1761                 }
1762                 if (dsp->fw_ver == 0) {
1763                         if (i + 1 < n_algs) {
1764                                 len = be32_to_cpu(adsp1_alg[i + 1].zm);
1765                                 len -= be32_to_cpu(adsp1_alg[i].zm);
1766                                 len *= 4;
1767                                 wm_adsp_create_control(dsp, alg_region, 0,
1768                                                        len, NULL, 0, 0);
1769                         } else {
1770                                 adsp_warn(dsp, "Missing length info for region ZM with ID %x\n",
1771                                           be32_to_cpu(adsp1_alg[i].alg.id));
1772                         }
1773                 }
1774         }
1775 
1776 out:
1777         kfree(adsp1_alg);
1778         return ret;
1779 }
1780 
1781 static int wm_adsp2_setup_algs(struct wm_adsp *dsp)
1782 {
1783         struct wmfw_adsp2_id_hdr adsp2_id;
1784         struct wmfw_adsp2_alg_hdr *adsp2_alg;
1785         struct wm_adsp_alg_region *alg_region;
1786         const struct wm_adsp_region *mem;
1787         unsigned int pos, len;
1788         size_t n_algs;
1789         int i, ret;
1790 
1791         mem = wm_adsp_find_region(dsp, WMFW_ADSP2_XM);
1792         if (WARN_ON(!mem))
1793                 return -EINVAL;
1794 
1795         ret = regmap_raw_read(dsp->regmap, mem->base, &adsp2_id,
1796                               sizeof(adsp2_id));
1797         if (ret != 0) {
1798                 adsp_err(dsp, "Failed to read algorithm info: %d\n",
1799                          ret);
1800                 return ret;
1801         }
1802 
1803         n_algs = be32_to_cpu(adsp2_id.n_algs);
1804         dsp->fw_id = be32_to_cpu(adsp2_id.fw.id);
1805         dsp->fw_id_version = be32_to_cpu(adsp2_id.fw.ver);
1806         adsp_info(dsp, "Firmware: %x v%d.%d.%d, %zu algorithms\n",
1807                   dsp->fw_id,
1808                   (dsp->fw_id_version & 0xff0000) >> 16,
1809                   (dsp->fw_id_version & 0xff00) >> 8,
1810                   dsp->fw_id_version & 0xff,
1811                   n_algs);
1812 
1813         alg_region = wm_adsp_create_region(dsp, WMFW_ADSP2_XM,
1814                                            adsp2_id.fw.id, adsp2_id.xm);
1815         if (IS_ERR(alg_region))
1816                 return PTR_ERR(alg_region);
1817 
1818         alg_region = wm_adsp_create_region(dsp, WMFW_ADSP2_YM,
1819                                            adsp2_id.fw.id, adsp2_id.ym);
1820         if (IS_ERR(alg_region))
1821                 return PTR_ERR(alg_region);
1822 
1823         alg_region = wm_adsp_create_region(dsp, WMFW_ADSP2_ZM,
1824                                            adsp2_id.fw.id, adsp2_id.zm);
1825         if (IS_ERR(alg_region))
1826                 return PTR_ERR(alg_region);
1827 
1828         pos = sizeof(adsp2_id) / 2;
1829         len = (sizeof(*adsp2_alg) * n_algs) / 2;
1830 
1831         adsp2_alg = wm_adsp_read_algs(dsp, n_algs, mem->base + pos, len);
1832         if (IS_ERR(adsp2_alg))
1833                 return PTR_ERR(adsp2_alg);
1834 
1835         for (i = 0; i < n_algs; i++) {
1836                 adsp_info(dsp,
1837                           "%d: ID %x v%d.%d.%d XM@%x YM@%x ZM@%x\n",
1838                           i, be32_to_cpu(adsp2_alg[i].alg.id),
1839                           (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff0000) >> 16,
1840                           (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff00) >> 8,
1841                           be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff,
1842                           be32_to_cpu(adsp2_alg[i].xm),
1843                           be32_to_cpu(adsp2_alg[i].ym),
1844                           be32_to_cpu(adsp2_alg[i].zm));
1845 
1846                 alg_region = wm_adsp_create_region(dsp, WMFW_ADSP2_XM,
1847                                                    adsp2_alg[i].alg.id,
1848                                                    adsp2_alg[i].xm);
1849                 if (IS_ERR(alg_region)) {
1850                         ret = PTR_ERR(alg_region);
1851                         goto out;
1852                 }
1853                 if (dsp->fw_ver == 0) {
1854                         if (i + 1 < n_algs) {
1855                                 len = be32_to_cpu(adsp2_alg[i + 1].xm);
1856                                 len -= be32_to_cpu(adsp2_alg[i].xm);
1857                                 len *= 4;
1858                                 wm_adsp_create_control(dsp, alg_region, 0,
1859                                                        len, NULL, 0, 0);
1860                         } else {
1861                                 adsp_warn(dsp, "Missing length info for region XM with ID %x\n",
1862                                           be32_to_cpu(adsp2_alg[i].alg.id));
1863                         }
1864                 }
1865 
1866                 alg_region = wm_adsp_create_region(dsp, WMFW_ADSP2_YM,
1867                                                    adsp2_alg[i].alg.id,
1868                                                    adsp2_alg[i].ym);
1869                 if (IS_ERR(alg_region)) {
1870                         ret = PTR_ERR(alg_region);
1871                         goto out;
1872                 }
1873                 if (dsp->fw_ver == 0) {
1874                         if (i + 1 < n_algs) {
1875                                 len = be32_to_cpu(adsp2_alg[i + 1].ym);
1876                                 len -= be32_to_cpu(adsp2_alg[i].ym);
1877                                 len *= 4;
1878                                 wm_adsp_create_control(dsp, alg_region, 0,
1879                                                        len, NULL, 0, 0);
1880                         } else {
1881                                 adsp_warn(dsp, "Missing length info for region YM with ID %x\n",
1882                                           be32_to_cpu(adsp2_alg[i].alg.id));
1883                         }
1884                 }
1885 
1886                 alg_region = wm_adsp_create_region(dsp, WMFW_ADSP2_ZM,
1887                                                    adsp2_alg[i].alg.id,
1888                                                    adsp2_alg[i].zm);
1889                 if (IS_ERR(alg_region)) {
1890                         ret = PTR_ERR(alg_region);
1891                         goto out;
1892                 }
1893                 if (dsp->fw_ver == 0) {
1894                         if (i + 1 < n_algs) {
1895                                 len = be32_to_cpu(adsp2_alg[i + 1].zm);
1896                                 len -= be32_to_cpu(adsp2_alg[i].zm);
1897                                 len *= 4;
1898                                 wm_adsp_create_control(dsp, alg_region, 0,
1899                                                        len, NULL, 0, 0);
1900                         } else {
1901                                 adsp_warn(dsp, "Missing length info for region ZM with ID %x\n",
1902                                           be32_to_cpu(adsp2_alg[i].alg.id));
1903                         }
1904                 }
1905         }
1906 
1907 out:
1908         kfree(adsp2_alg);
1909         return ret;
1910 }
1911 
1912 static int wm_adsp_load_coeff(struct wm_adsp *dsp)
1913 {
1914         LIST_HEAD(buf_list);
1915         struct regmap *regmap = dsp->regmap;
1916         struct wmfw_coeff_hdr *hdr;
1917         struct wmfw_coeff_item *blk;
1918         const struct firmware *firmware;
1919         const struct wm_adsp_region *mem;
1920         struct wm_adsp_alg_region *alg_region;
1921         const char *region_name;
1922         int ret, pos, blocks, type, offset, reg;
1923         char *file;
1924         struct wm_adsp_buf *buf;
1925 
1926         file = kzalloc(PAGE_SIZE, GFP_KERNEL);
1927         if (file == NULL)
1928                 return -ENOMEM;
1929 
1930         snprintf(file, PAGE_SIZE, "%s-dsp%d-%s.bin", dsp->part, dsp->num,
1931                  wm_adsp_fw[dsp->fw].file);
1932         file[PAGE_SIZE - 1] = '\0';
1933 
1934         ret = request_firmware(&firmware, file, dsp->dev);
1935         if (ret != 0) {
1936                 adsp_warn(dsp, "Failed to request '%s'\n", file);
1937                 ret = 0;
1938                 goto out;
1939         }
1940         ret = -EINVAL;
1941 
1942         if (sizeof(*hdr) >= firmware->size) {
1943                 adsp_err(dsp, "%s: file too short, %zu bytes\n",
1944                         file, firmware->size);
1945                 goto out_fw;
1946         }
1947 
1948         hdr = (void *)&firmware->data[0];
1949         if (memcmp(hdr->magic, "WMDR", 4) != 0) {
1950                 adsp_err(dsp, "%s: invalid magic\n", file);
1951                 goto out_fw;
1952         }
1953 
1954         switch (be32_to_cpu(hdr->rev) & 0xff) {
1955         case 1:
1956                 break;
1957         default:
1958                 adsp_err(dsp, "%s: Unsupported coefficient file format %d\n",
1959                          file, be32_to_cpu(hdr->rev) & 0xff);
1960                 ret = -EINVAL;
1961                 goto out_fw;
1962         }
1963 
1964         adsp_dbg(dsp, "%s: v%d.%d.%d\n", file,
1965                 (le32_to_cpu(hdr->ver) >> 16) & 0xff,
1966                 (le32_to_cpu(hdr->ver) >>  8) & 0xff,
1967                 le32_to_cpu(hdr->ver) & 0xff);
1968 
1969         pos = le32_to_cpu(hdr->len);
1970 
1971         blocks = 0;
1972         while (pos < firmware->size &&
1973                pos - firmware->size > sizeof(*blk)) {
1974                 blk = (void *)(&firmware->data[pos]);
1975 
1976                 type = le16_to_cpu(blk->type);
1977                 offset = le16_to_cpu(blk->offset);
1978 
1979                 adsp_dbg(dsp, "%s.%d: %x v%d.%d.%d\n",
1980                          file, blocks, le32_to_cpu(blk->id),
1981                          (le32_to_cpu(blk->ver) >> 16) & 0xff,
1982                          (le32_to_cpu(blk->ver) >>  8) & 0xff,
1983                          le32_to_cpu(blk->ver) & 0xff);
1984                 adsp_dbg(dsp, "%s.%d: %d bytes at 0x%x in %x\n",
1985                          file, blocks, le32_to_cpu(blk->len), offset, type);
1986 
1987                 reg = 0;
1988                 region_name = "Unknown";
1989                 switch (type) {
1990                 case (WMFW_NAME_TEXT << 8):
1991                 case (WMFW_INFO_TEXT << 8):
1992                         break;
1993                 case (WMFW_ABSOLUTE << 8):
1994                         /*
1995                          * Old files may use this for global
1996                          * coefficients.
1997                          */
1998                         if (le32_to_cpu(blk->id) == dsp->fw_id &&
1999                             offset == 0) {
2000                                 region_name = "global coefficients";
2001                                 mem = wm_adsp_find_region(dsp, type);
2002                                 if (!mem) {
2003                                         adsp_err(dsp, "No ZM\n");
2004                                         break;
2005                                 }
2006                                 reg = wm_adsp_region_to_reg(mem, 0);
2007 
2008                         } else {
2009                                 region_name = "register";
2010                                 reg = offset;
2011                         }
2012                         break;
2013 
2014                 case WMFW_ADSP1_DM:
2015                 case WMFW_ADSP1_ZM:
2016                 case WMFW_ADSP2_XM:
2017                 case WMFW_ADSP2_YM:
2018                         adsp_dbg(dsp, "%s.%d: %d bytes in %x for %x\n",
2019                                  file, blocks, le32_to_cpu(blk->len),
2020                                  type, le32_to_cpu(blk->id));
2021 
2022                         mem = wm_adsp_find_region(dsp, type);
2023                         if (!mem) {
2024                                 adsp_err(dsp, "No base for region %x\n", type);
2025                                 break;
2026                         }
2027 
2028                         alg_region = wm_adsp_find_alg_region(dsp, type,
2029                                                 le32_to_cpu(blk->id));
2030                         if (alg_region) {
2031                                 reg = alg_region->base;
2032                                 reg = wm_adsp_region_to_reg(mem, reg);
2033                                 reg += offset;
2034                         } else {
2035                                 adsp_err(dsp, "No %x for algorithm %x\n",
2036                                          type, le32_to_cpu(blk->id));
2037                         }
2038                         break;
2039 
2040                 default:
2041                         adsp_err(dsp, "%s.%d: Unknown region type %x at %d\n",
2042                                  file, blocks, type, pos);
2043                         break;
2044                 }
2045 
2046                 if (reg) {
2047                         buf = wm_adsp_buf_alloc(blk->data,
2048                                                 le32_to_cpu(blk->len),
2049                                                 &buf_list);
2050                         if (!buf) {
2051                                 adsp_err(dsp, "Out of memory\n");
2052                                 ret = -ENOMEM;
2053                                 goto out_fw;
2054                         }
2055 
2056                         adsp_dbg(dsp, "%s.%d: Writing %d bytes at %x\n",
2057                                  file, blocks, le32_to_cpu(blk->len),
2058                                  reg);
2059                         ret = regmap_raw_write_async(regmap, reg, buf->buf,
2060                                                      le32_to_cpu(blk->len));
2061                         if (ret != 0) {
2062                                 adsp_err(dsp,
2063                                         "%s.%d: Failed to write to %x in %s: %d\n",
2064                                         file, blocks, reg, region_name, ret);
2065                         }
2066                 }
2067 
2068                 pos += (le32_to_cpu(blk->len) + sizeof(*blk) + 3) & ~0x03;
2069                 blocks++;
2070         }
2071 
2072         ret = regmap_async_complete(regmap);
2073         if (ret != 0)
2074                 adsp_err(dsp, "Failed to complete async write: %d\n", ret);
2075 
2076         if (pos > firmware->size)
2077                 adsp_warn(dsp, "%s.%d: %zu bytes at end of file\n",
2078                           file, blocks, pos - firmware->size);
2079 
2080         wm_adsp_debugfs_save_binname(dsp, file);
2081 
2082 out_fw:
2083         regmap_async_complete(regmap);
2084         release_firmware(firmware);
2085         wm_adsp_buf_free(&buf_list);
2086 out:
2087         kfree(file);
2088         return ret;
2089 }
2090 
2091 int wm_adsp1_init(struct wm_adsp *dsp)
2092 {
2093         INIT_LIST_HEAD(&dsp->alg_regions);
2094 
2095         mutex_init(&dsp->pwr_lock);
2096 
2097         return 0;
2098 }
2099 EXPORT_SYMBOL_GPL(wm_adsp1_init);
2100 
2101 int wm_adsp1_event(struct snd_soc_dapm_widget *w,
2102                    struct snd_kcontrol *kcontrol,
2103                    int event)
2104 {
2105         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
2106         struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);
2107         struct wm_adsp *dsp = &dsps[w->shift];
2108         struct wm_coeff_ctl *ctl;
2109         int ret;
2110         unsigned int val;
2111 
2112         dsp->card = codec->component.card;
2113 
2114         mutex_lock(&dsp->pwr_lock);
2115 
2116         switch (event) {
2117         case SND_SOC_DAPM_POST_PMU:
2118                 regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,
2119                                    ADSP1_SYS_ENA, ADSP1_SYS_ENA);
2120 
2121                 /*
2122                  * For simplicity set the DSP clock rate to be the
2123                  * SYSCLK rate rather than making it configurable.
2124                  */
2125                 if (dsp->sysclk_reg) {
2126                         ret = regmap_read(dsp->regmap, dsp->sysclk_reg, &val);
2127                         if (ret != 0) {
2128                                 adsp_err(dsp, "Failed to read SYSCLK state: %d\n",
2129                                 ret);
2130                                 goto err_mutex;
2131                         }
2132 
2133                         val = (val & dsp->sysclk_mask) >> dsp->sysclk_shift;
2134 
2135                         ret = regmap_update_bits(dsp->regmap,
2136                                                  dsp->base + ADSP1_CONTROL_31,
2137                                                  ADSP1_CLK_SEL_MASK, val);
2138                         if (ret != 0) {
2139                                 adsp_err(dsp, "Failed to set clock rate: %d\n",
2140                                          ret);
2141                                 goto err_mutex;
2142                         }
2143                 }
2144 
2145                 ret = wm_adsp_load(dsp);
2146                 if (ret != 0)
2147                         goto err_ena;
2148 
2149                 ret = wm_adsp1_setup_algs(dsp);
2150                 if (ret != 0)
2151                         goto err_ena;
2152 
2153                 ret = wm_adsp_load_coeff(dsp);
2154                 if (ret != 0)
2155                         goto err_ena;
2156 
2157                 /* Initialize caches for enabled and unset controls */
2158                 ret = wm_coeff_init_control_caches(dsp);
2159                 if (ret != 0)
2160                         goto err_ena;
2161 
2162                 /* Sync set controls */
2163                 ret = wm_coeff_sync_controls(dsp);
2164                 if (ret != 0)
2165                         goto err_ena;
2166 
2167                 /* Start the core running */
2168                 regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,
2169                                    ADSP1_CORE_ENA | ADSP1_START,
2170                                    ADSP1_CORE_ENA | ADSP1_START);
2171                 break;
2172 
2173         case SND_SOC_DAPM_PRE_PMD:
2174                 /* Halt the core */
2175                 regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,
2176                                    ADSP1_CORE_ENA | ADSP1_START, 0);
2177 
2178                 regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_19,
2179                                    ADSP1_WDMA_BUFFER_LENGTH_MASK, 0);
2180 
2181                 regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,
2182                                    ADSP1_SYS_ENA, 0);
2183 
2184                 list_for_each_entry(ctl, &dsp->ctl_list, list)
2185                         ctl->enabled = 0;
2186 
2187 
2188                 wm_adsp_free_alg_regions(dsp);
2189                 break;
2190 
2191         default:
2192                 break;
2193         }
2194 
2195         mutex_unlock(&dsp->pwr_lock);
2196 
2197         return 0;
2198 
2199 err_ena:
2200         regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,
2201                            ADSP1_SYS_ENA, 0);
2202 err_mutex:
2203         mutex_unlock(&dsp->pwr_lock);
2204 
2205         return ret;
2206 }
2207 EXPORT_SYMBOL_GPL(wm_adsp1_event);
2208 
2209 static int wm_adsp2_ena(struct wm_adsp *dsp)
2210 {
2211         unsigned int val;
2212         int ret, count;
2213 
2214         ret = regmap_update_bits_async(dsp->regmap, dsp->base + ADSP2_CONTROL,
2215                                        ADSP2_SYS_ENA, ADSP2_SYS_ENA);
2216         if (ret != 0)
2217                 return ret;
2218 
2219         /* Wait for the RAM to start, should be near instantaneous */
2220         for (count = 0; count < 10; ++count) {
2221                 ret = regmap_read(dsp->regmap, dsp->base + ADSP2_STATUS1, &val);
2222                 if (ret != 0)
2223                         return ret;
2224 
2225                 if (val & ADSP2_RAM_RDY)
2226                         break;
2227 
2228                 msleep(1);
2229         }
2230 
2231         if (!(val & ADSP2_RAM_RDY)) {
2232                 adsp_err(dsp, "Failed to start DSP RAM\n");
2233                 return -EBUSY;
2234         }
2235 
2236         adsp_dbg(dsp, "RAM ready after %d polls\n", count);
2237 
2238         return 0;
2239 }
2240 
2241 static void wm_adsp2_boot_work(struct work_struct *work)
2242 {
2243         struct wm_adsp *dsp = container_of(work,
2244                                            struct wm_adsp,
2245                                            boot_work);
2246         int ret;
2247 
2248         mutex_lock(&dsp->pwr_lock);
2249 
2250         ret = wm_adsp2_ena(dsp);
2251         if (ret != 0)
2252                 goto err_mutex;
2253 
2254         ret = wm_adsp_load(dsp);
2255         if (ret != 0)
2256                 goto err_ena;
2257 
2258         ret = wm_adsp2_setup_algs(dsp);
2259         if (ret != 0)
2260                 goto err_ena;
2261 
2262         ret = wm_adsp_load_coeff(dsp);
2263         if (ret != 0)
2264                 goto err_ena;
2265 
2266         /* Initialize caches for enabled and unset controls */
2267         ret = wm_coeff_init_control_caches(dsp);
2268         if (ret != 0)
2269                 goto err_ena;
2270 
2271         /* Sync set controls */
2272         ret = wm_coeff_sync_controls(dsp);
2273         if (ret != 0)
2274                 goto err_ena;
2275 
2276         dsp->running = true;
2277 
2278         mutex_unlock(&dsp->pwr_lock);
2279 
2280         return;
2281 
2282 err_ena:
2283         regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,
2284                            ADSP2_SYS_ENA | ADSP2_CORE_ENA | ADSP2_START, 0);
2285 err_mutex:
2286         mutex_unlock(&dsp->pwr_lock);
2287 }
2288 
2289 static void wm_adsp2_set_dspclk(struct wm_adsp *dsp, unsigned int freq)
2290 {
2291         int ret;
2292 
2293         ret = regmap_update_bits_async(dsp->regmap,
2294                                        dsp->base + ADSP2_CLOCKING,
2295                                        ADSP2_CLK_SEL_MASK,
2296                                        freq << ADSP2_CLK_SEL_SHIFT);
2297         if (ret != 0)
2298                 adsp_err(dsp, "Failed to set clock rate: %d\n", ret);
2299 }
2300 
2301 int wm_adsp2_early_event(struct snd_soc_dapm_widget *w,
2302                          struct snd_kcontrol *kcontrol, int event,
2303                          unsigned int freq)
2304 {
2305         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
2306         struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);
2307         struct wm_adsp *dsp = &dsps[w->shift];
2308 
2309         dsp->card = codec->component.card;
2310 
2311         switch (event) {
2312         case SND_SOC_DAPM_PRE_PMU:
2313                 wm_adsp2_set_dspclk(dsp, freq);
2314                 queue_work(system_unbound_wq, &dsp->boot_work);
2315                 break;
2316         default:
2317                 break;
2318         }
2319 
2320         return 0;
2321 }
2322 EXPORT_SYMBOL_GPL(wm_adsp2_early_event);
2323 
2324 int wm_adsp2_event(struct snd_soc_dapm_widget *w,
2325                    struct snd_kcontrol *kcontrol, int event)
2326 {
2327         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
2328         struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);
2329         struct wm_adsp *dsp = &dsps[w->shift];
2330         struct wm_coeff_ctl *ctl;
2331         int ret;
2332 
2333         switch (event) {
2334         case SND_SOC_DAPM_POST_PMU:
2335                 flush_work(&dsp->boot_work);
2336 
2337                 if (!dsp->running)
2338                         return -EIO;
2339 
2340                 ret = regmap_update_bits(dsp->regmap,
2341                                          dsp->base + ADSP2_CONTROL,
2342                                          ADSP2_CORE_ENA | ADSP2_START,
2343                                          ADSP2_CORE_ENA | ADSP2_START);
2344                 if (ret != 0)
2345                         goto err;
2346 
2347                 mutex_lock(&dsp->pwr_lock);
2348 
2349                 if (wm_adsp_fw[dsp->fw].num_caps != 0)
2350                         ret = wm_adsp_buffer_init(dsp);
2351 
2352                 mutex_unlock(&dsp->pwr_lock);
2353 
2354                 break;
2355 
2356         case SND_SOC_DAPM_PRE_PMD:
2357                 /* Log firmware state, it can be useful for analysis */
2358                 wm_adsp2_show_fw_status(dsp);
2359 
2360                 mutex_lock(&dsp->pwr_lock);
2361 
2362                 wm_adsp_debugfs_clear(dsp);
2363 
2364                 dsp->fw_id = 0;
2365                 dsp->fw_id_version = 0;
2366                 dsp->running = false;
2367 
2368                 regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,
2369                                    ADSP2_SYS_ENA | ADSP2_CORE_ENA |
2370                                    ADSP2_START, 0);
2371 
2372                 /* Make sure DMAs are quiesced */
2373                 regmap_write(dsp->regmap, dsp->base + ADSP2_WDMA_CONFIG_1, 0);
2374                 regmap_write(dsp->regmap, dsp->base + ADSP2_WDMA_CONFIG_2, 0);
2375                 regmap_write(dsp->regmap, dsp->base + ADSP2_RDMA_CONFIG_1, 0);
2376 
2377                 list_for_each_entry(ctl, &dsp->ctl_list, list)
2378                         ctl->enabled = 0;
2379 
2380                 wm_adsp_free_alg_regions(dsp);
2381 
2382                 if (wm_adsp_fw[dsp->fw].num_caps != 0)
2383                         wm_adsp_buffer_free(dsp);
2384 
2385                 mutex_unlock(&dsp->pwr_lock);
2386 
2387                 adsp_dbg(dsp, "Shutdown complete\n");
2388                 break;
2389 
2390         default:
2391                 break;
2392         }
2393 
2394         return 0;
2395 err:
2396         regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,
2397                            ADSP2_SYS_ENA | ADSP2_CORE_ENA | ADSP2_START, 0);
2398         return ret;
2399 }
2400 EXPORT_SYMBOL_GPL(wm_adsp2_event);
2401 
2402 int wm_adsp2_codec_probe(struct wm_adsp *dsp, struct snd_soc_codec *codec)
2403 {
2404         wm_adsp2_init_debugfs(dsp, codec);
2405 
2406         return snd_soc_add_codec_controls(codec,
2407                                           &wm_adsp_fw_controls[dsp->num - 1],
2408                                           1);
2409 }
2410 EXPORT_SYMBOL_GPL(wm_adsp2_codec_probe);
2411 
2412 int wm_adsp2_codec_remove(struct wm_adsp *dsp, struct snd_soc_codec *codec)
2413 {
2414         wm_adsp2_cleanup_debugfs(dsp);
2415 
2416         return 0;
2417 }
2418 EXPORT_SYMBOL_GPL(wm_adsp2_codec_remove);
2419 
2420 int wm_adsp2_init(struct wm_adsp *dsp)
2421 {
2422         int ret;
2423 
2424         /*
2425          * Disable the DSP memory by default when in reset for a small
2426          * power saving.
2427          */
2428         ret = regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,
2429                                  ADSP2_MEM_ENA, 0);
2430         if (ret != 0) {
2431                 adsp_err(dsp, "Failed to clear memory retention: %d\n", ret);
2432                 return ret;
2433         }
2434 
2435         INIT_LIST_HEAD(&dsp->alg_regions);
2436         INIT_LIST_HEAD(&dsp->ctl_list);
2437         INIT_WORK(&dsp->boot_work, wm_adsp2_boot_work);
2438 
2439         mutex_init(&dsp->pwr_lock);
2440 
2441         return 0;
2442 }
2443 EXPORT_SYMBOL_GPL(wm_adsp2_init);
2444 
2445 void wm_adsp2_remove(struct wm_adsp *dsp)
2446 {
2447         struct wm_coeff_ctl *ctl;
2448 
2449         while (!list_empty(&dsp->ctl_list)) {
2450                 ctl = list_first_entry(&dsp->ctl_list, struct wm_coeff_ctl,
2451                                         list);
2452                 list_del(&ctl->list);
2453                 wm_adsp_free_ctl_blk(ctl);
2454         }
2455 }
2456 EXPORT_SYMBOL_GPL(wm_adsp2_remove);
2457 
2458 static inline int wm_adsp_compr_attached(struct wm_adsp_compr *compr)
2459 {
2460         return compr->buf != NULL;
2461 }
2462 
2463 static int wm_adsp_compr_attach(struct wm_adsp_compr *compr)
2464 {
2465         /*
2466          * Note this will be more complex once each DSP can support multiple
2467          * streams
2468          */
2469         if (!compr->dsp->buffer)
2470                 return -EINVAL;
2471 
2472         compr->buf = compr->dsp->buffer;
2473         compr->buf->compr = compr;
2474 
2475         return 0;
2476 }
2477 
2478 static void wm_adsp_compr_detach(struct wm_adsp_compr *compr)
2479 {
2480         if (!compr)
2481                 return;
2482 
2483         /* Wake the poll so it can see buffer is no longer attached */
2484         if (compr->stream)
2485                 snd_compr_fragment_elapsed(compr->stream);
2486 
2487         if (wm_adsp_compr_attached(compr)) {
2488                 compr->buf->compr = NULL;
2489                 compr->buf = NULL;
2490         }
2491 }
2492 
2493 int wm_adsp_compr_open(struct wm_adsp *dsp, struct snd_compr_stream *stream)
2494 {
2495         struct wm_adsp_compr *compr;
2496         int ret = 0;
2497 
2498         mutex_lock(&dsp->pwr_lock);
2499 
2500         if (wm_adsp_fw[dsp->fw].num_caps == 0) {
2501                 adsp_err(dsp, "Firmware does not support compressed API\n");
2502                 ret = -ENXIO;
2503                 goto out;
2504         }
2505 
2506         if (wm_adsp_fw[dsp->fw].compr_direction != stream->direction) {
2507                 adsp_err(dsp, "Firmware does not support stream direction\n");
2508                 ret = -EINVAL;
2509                 goto out;
2510         }
2511 
2512         if (dsp->compr) {
2513                 /* It is expect this limitation will be removed in future */
2514                 adsp_err(dsp, "Only a single stream supported per DSP\n");
2515                 ret = -EBUSY;
2516                 goto out;
2517         }
2518 
2519         compr = kzalloc(sizeof(*compr), GFP_KERNEL);
2520         if (!compr) {
2521                 ret = -ENOMEM;
2522                 goto out;
2523         }
2524 
2525         compr->dsp = dsp;
2526         compr->stream = stream;
2527 
2528         dsp->compr = compr;
2529 
2530         stream->runtime->private_data = compr;
2531 
2532 out:
2533         mutex_unlock(&dsp->pwr_lock);
2534 
2535         return ret;
2536 }
2537 EXPORT_SYMBOL_GPL(wm_adsp_compr_open);
2538 
2539 int wm_adsp_compr_free(struct snd_compr_stream *stream)
2540 {
2541         struct wm_adsp_compr *compr = stream->runtime->private_data;
2542         struct wm_adsp *dsp = compr->dsp;
2543 
2544         mutex_lock(&dsp->pwr_lock);
2545 
2546         wm_adsp_compr_detach(compr);
2547         dsp->compr = NULL;
2548 
2549         kfree(compr->raw_buf);
2550         kfree(compr);
2551 
2552         mutex_unlock(&dsp->pwr_lock);
2553 
2554         return 0;
2555 }
2556 EXPORT_SYMBOL_GPL(wm_adsp_compr_free);
2557 
2558 static int wm_adsp_compr_check_params(struct snd_compr_stream *stream,
2559                                       struct snd_compr_params *params)
2560 {
2561         struct wm_adsp_compr *compr = stream->runtime->private_data;
2562         struct wm_adsp *dsp = compr->dsp;
2563         const struct wm_adsp_fw_caps *caps;
2564         const struct snd_codec_desc *desc;
2565         int i, j;
2566 
2567         if (params->buffer.fragment_size < WM_ADSP_MIN_FRAGMENT_SIZE ||
2568             params->buffer.fragment_size > WM_ADSP_MAX_FRAGMENT_SIZE ||
2569             params->buffer.fragments < WM_ADSP_MIN_FRAGMENTS ||
2570             params->buffer.fragments > WM_ADSP_MAX_FRAGMENTS ||
2571             params->buffer.fragment_size % WM_ADSP_DATA_WORD_SIZE) {
2572                 adsp_err(dsp, "Invalid buffer fragsize=%d fragments=%d\n",
2573                          params->buffer.fragment_size,
2574                          params->buffer.fragments);
2575 
2576                 return -EINVAL;
2577         }
2578 
2579         for (i = 0; i < wm_adsp_fw[dsp->fw].num_caps; i++) {
2580                 caps = &wm_adsp_fw[dsp->fw].caps[i];
2581                 desc = &caps->desc;
2582 
2583                 if (caps->id != params->codec.id)
2584                         continue;
2585 
2586                 if (stream->direction == SND_COMPRESS_PLAYBACK) {
2587                         if (desc->max_ch < params->codec.ch_out)
2588                                 continue;
2589                 } else {
2590                         if (desc->max_ch < params->codec.ch_in)
2591                                 continue;
2592                 }
2593 
2594                 if (!(desc->formats & (1 << params->codec.format)))
2595                         continue;
2596 
2597                 for (j = 0; j < desc->num_sample_rates; ++j)
2598                         if (desc->sample_rates[j] == params->codec.sample_rate)
2599                                 return 0;
2600         }
2601 
2602         adsp_err(dsp, "Invalid params id=%u ch=%u,%u rate=%u fmt=%u\n",
2603                  params->codec.id, params->codec.ch_in, params->codec.ch_out,
2604                  params->codec.sample_rate, params->codec.format);
2605         return -EINVAL;
2606 }
2607 
2608 static inline unsigned int wm_adsp_compr_frag_words(struct wm_adsp_compr *compr)
2609 {
2610         return compr->size.fragment_size / WM_ADSP_DATA_WORD_SIZE;
2611 }
2612 
2613 int wm_adsp_compr_set_params(struct snd_compr_stream *stream,
2614                              struct snd_compr_params *params)
2615 {
2616         struct wm_adsp_compr *compr = stream->runtime->private_data;
2617         unsigned int size;
2618         int ret;
2619 
2620         ret = wm_adsp_compr_check_params(stream, params);
2621         if (ret)
2622                 return ret;
2623 
2624         compr->size = params->buffer;
2625 
2626         adsp_dbg(compr->dsp, "fragment_size=%d fragments=%d\n",
2627                  compr->size.fragment_size, compr->size.fragments);
2628 
2629         size = wm_adsp_compr_frag_words(compr) * sizeof(*compr->raw_buf);
2630         compr->raw_buf = kmalloc(size, GFP_DMA | GFP_KERNEL);
2631         if (!compr->raw_buf)
2632                 return -ENOMEM;
2633 
2634         compr->sample_rate = params->codec.sample_rate;
2635 
2636         return 0;
2637 }
2638 EXPORT_SYMBOL_GPL(wm_adsp_compr_set_params);
2639 
2640 int wm_adsp_compr_get_caps(struct snd_compr_stream *stream,
2641                            struct snd_compr_caps *caps)
2642 {
2643         struct wm_adsp_compr *compr = stream->runtime->private_data;
2644         int fw = compr->dsp->fw;
2645         int i;
2646 
2647         if (wm_adsp_fw[fw].caps) {
2648                 for (i = 0; i < wm_adsp_fw[fw].num_caps; i++)
2649                         caps->codecs[i] = wm_adsp_fw[fw].caps[i].id;
2650 
2651                 caps->num_codecs = i;
2652                 caps->direction = wm_adsp_fw[fw].compr_direction;
2653 
2654                 caps->min_fragment_size = WM_ADSP_MIN_FRAGMENT_SIZE;
2655                 caps->max_fragment_size = WM_ADSP_MAX_FRAGMENT_SIZE;
2656                 caps->min_fragments = WM_ADSP_MIN_FRAGMENTS;
2657                 caps->max_fragments = WM_ADSP_MAX_FRAGMENTS;
2658         }
2659 
2660         return 0;
2661 }
2662 EXPORT_SYMBOL_GPL(wm_adsp_compr_get_caps);
2663 
2664 static int wm_adsp_read_data_block(struct wm_adsp *dsp, int mem_type,
2665                                    unsigned int mem_addr,
2666                                    unsigned int num_words, u32 *data)
2667 {
2668         struct wm_adsp_region const *mem = wm_adsp_find_region(dsp, mem_type);
2669         unsigned int i, reg;
2670         int ret;
2671 
2672         if (!mem)
2673                 return -EINVAL;
2674 
2675         reg = wm_adsp_region_to_reg(mem, mem_addr);
2676 
2677         ret = regmap_raw_read(dsp->regmap, reg, data,
2678                               sizeof(*data) * num_words);
2679         if (ret < 0)
2680                 return ret;
2681 
2682         for (i = 0; i < num_words; ++i)
2683                 data[i] = be32_to_cpu(data[i]) & 0x00ffffffu;
2684 
2685         return 0;
2686 }
2687 
2688 static inline int wm_adsp_read_data_word(struct wm_adsp *dsp, int mem_type,
2689                                          unsigned int mem_addr, u32 *data)
2690 {
2691         return wm_adsp_read_data_block(dsp, mem_type, mem_addr, 1, data);
2692 }
2693 
2694 static int wm_adsp_write_data_word(struct wm_adsp *dsp, int mem_type,
2695                                    unsigned int mem_addr, u32 data)
2696 {
2697         struct wm_adsp_region const *mem = wm_adsp_find_region(dsp, mem_type);
2698         unsigned int reg;
2699 
2700         if (!mem)
2701                 return -EINVAL;
2702 
2703         reg = wm_adsp_region_to_reg(mem, mem_addr);
2704 
2705         data = cpu_to_be32(data & 0x00ffffffu);
2706 
2707         return regmap_raw_write(dsp->regmap, reg, &data, sizeof(data));
2708 }
2709 
2710 static inline int wm_adsp_buffer_read(struct wm_adsp_compr_buf *buf,
2711                                       unsigned int field_offset, u32 *data)
2712 {
2713         return wm_adsp_read_data_word(buf->dsp, WMFW_ADSP2_XM,
2714                                       buf->host_buf_ptr + field_offset, data);
2715 }
2716 
2717 static inline int wm_adsp_buffer_write(struct wm_adsp_compr_buf *buf,
2718                                        unsigned int field_offset, u32 data)
2719 {
2720         return wm_adsp_write_data_word(buf->dsp, WMFW_ADSP2_XM,
2721                                        buf->host_buf_ptr + field_offset, data);
2722 }
2723 
2724 static int wm_adsp_buffer_locate(struct wm_adsp_compr_buf *buf)
2725 {
2726         struct wm_adsp_alg_region *alg_region;
2727         struct wm_adsp *dsp = buf->dsp;
2728         u32 xmalg, addr, magic;
2729         int i, ret;
2730 
2731         alg_region = wm_adsp_find_alg_region(dsp, WMFW_ADSP2_XM, dsp->fw_id);
2732         xmalg = sizeof(struct wm_adsp_system_config_xm_hdr) / sizeof(__be32);
2733 
2734         addr = alg_region->base + xmalg + ALG_XM_FIELD(magic);
2735         ret = wm_adsp_read_data_word(dsp, WMFW_ADSP2_XM, addr, &magic);
2736         if (ret < 0)
2737                 return ret;
2738 
2739         if (magic != WM_ADSP_ALG_XM_STRUCT_MAGIC)
2740                 return -EINVAL;
2741 
2742         addr = alg_region->base + xmalg + ALG_XM_FIELD(host_buf_ptr);
2743         for (i = 0; i < 5; ++i) {
2744                 ret = wm_adsp_read_data_word(dsp, WMFW_ADSP2_XM, addr,
2745                                              &buf->host_buf_ptr);
2746                 if (ret < 0)
2747                         return ret;
2748 
2749                 if (buf->host_buf_ptr)
2750                         break;
2751 
2752                 usleep_range(1000, 2000);
2753         }
2754 
2755         if (!buf->host_buf_ptr)
2756                 return -EIO;
2757 
2758         adsp_dbg(dsp, "host_buf_ptr=%x\n", buf->host_buf_ptr);
2759 
2760         return 0;
2761 }
2762 
2763 static int wm_adsp_buffer_populate(struct wm_adsp_compr_buf *buf)
2764 {
2765         const struct wm_adsp_fw_caps *caps = wm_adsp_fw[buf->dsp->fw].caps;
2766         struct wm_adsp_buffer_region *region;
2767         u32 offset = 0;
2768         int i, ret;
2769 
2770         for (i = 0; i < caps->num_regions; ++i) {
2771                 region = &buf->regions[i];
2772 
2773                 region->offset = offset;
2774                 region->mem_type = caps->region_defs[i].mem_type;
2775 
2776                 ret = wm_adsp_buffer_read(buf, caps->region_defs[i].base_offset,
2777                                           &region->base_addr);
2778                 if (ret < 0)
2779                         return ret;
2780 
2781                 ret = wm_adsp_buffer_read(buf, caps->region_defs[i].size_offset,
2782                                           &offset);
2783                 if (ret < 0)
2784                         return ret;
2785 
2786                 region->cumulative_size = offset;
2787 
2788                 adsp_dbg(buf->dsp,
2789                          "region=%d type=%d base=%04x off=%04x size=%04x\n",
2790                          i, region->mem_type, region->base_addr,
2791                          region->offset, region->cumulative_size);
2792         }
2793 
2794         return 0;
2795 }
2796 
2797 static int wm_adsp_buffer_init(struct wm_adsp *dsp)
2798 {
2799         struct wm_adsp_compr_buf *buf;
2800         int ret;
2801 
2802         buf = kzalloc(sizeof(*buf), GFP_KERNEL);
2803         if (!buf)
2804                 return -ENOMEM;
2805 
2806         buf->dsp = dsp;
2807         buf->read_index = -1;
2808         buf->irq_count = 0xFFFFFFFF;
2809 
2810         ret = wm_adsp_buffer_locate(buf);
2811         if (ret < 0) {
2812                 adsp_err(dsp, "Failed to acquire host buffer: %d\n", ret);
2813                 goto err_buffer;
2814         }
2815 
2816         buf->regions = kcalloc(wm_adsp_fw[dsp->fw].caps->num_regions,
2817                                sizeof(*buf->regions), GFP_KERNEL);
2818         if (!buf->regions) {
2819                 ret = -ENOMEM;
2820                 goto err_buffer;
2821         }
2822 
2823         ret = wm_adsp_buffer_populate(buf);
2824         if (ret < 0) {
2825                 adsp_err(dsp, "Failed to populate host buffer: %d\n", ret);
2826                 goto err_regions;
2827         }
2828 
2829         dsp->buffer = buf;
2830 
2831         return 0;
2832 
2833 err_regions:
2834         kfree(buf->regions);
2835 err_buffer:
2836         kfree(buf);
2837         return ret;
2838 }
2839 
2840 static int wm_adsp_buffer_free(struct wm_adsp *dsp)
2841 {
2842         if (dsp->buffer) {
2843                 wm_adsp_compr_detach(dsp->buffer->compr);
2844 
2845                 kfree(dsp->buffer->regions);
2846                 kfree(dsp->buffer);
2847 
2848                 dsp->buffer = NULL;
2849         }
2850 
2851         return 0;
2852 }
2853 
2854 int wm_adsp_compr_trigger(struct snd_compr_stream *stream, int cmd)
2855 {
2856         struct wm_adsp_compr *compr = stream->runtime->private_data;
2857         struct wm_adsp *dsp = compr->dsp;
2858         int ret = 0;
2859 
2860         adsp_dbg(dsp, "Trigger: %d\n", cmd);
2861 
2862         mutex_lock(&dsp->pwr_lock);
2863 
2864         switch (cmd) {
2865         case SNDRV_PCM_TRIGGER_START:
2866                 if (wm_adsp_compr_attached(compr))
2867                         break;
2868 
2869                 ret = wm_adsp_compr_attach(compr);
2870                 if (ret < 0) {
2871                         adsp_err(dsp, "Failed to link buffer and stream: %d\n",
2872                                  ret);
2873                         break;
2874                 }
2875 
2876                 /* Trigger the IRQ at one fragment of data */
2877                 ret = wm_adsp_buffer_write(compr->buf,
2878                                            HOST_BUFFER_FIELD(high_water_mark),
2879                                            wm_adsp_compr_frag_words(compr));
2880                 if (ret < 0) {
2881                         adsp_err(dsp, "Failed to set high water mark: %d\n",
2882                                  ret);
2883                         break;
2884                 }
2885                 break;
2886         case SNDRV_PCM_TRIGGER_STOP:
2887                 break;
2888         default:
2889                 ret = -EINVAL;
2890                 break;
2891         }
2892 
2893         mutex_unlock(&dsp->pwr_lock);
2894 
2895         return ret;
2896 }
2897 EXPORT_SYMBOL_GPL(wm_adsp_compr_trigger);
2898 
2899 static inline int wm_adsp_buffer_size(struct wm_adsp_compr_buf *buf)
2900 {
2901         int last_region = wm_adsp_fw[buf->dsp->fw].caps->num_regions - 1;
2902 
2903         return buf->regions[last_region].cumulative_size;
2904 }
2905 
2906 static int wm_adsp_buffer_update_avail(struct wm_adsp_compr_buf *buf)
2907 {
2908         u32 next_read_index, next_write_index;
2909         int write_index, read_index, avail;
2910         int ret;
2911 
2912         /* Only sync read index if we haven't already read a valid index */
2913         if (buf->read_index < 0) {
2914                 ret = wm_adsp_buffer_read(buf,
2915                                 HOST_BUFFER_FIELD(next_read_index),
2916                                 &next_read_index);
2917                 if (ret < 0)
2918                         return ret;
2919 
2920                 read_index = sign_extend32(next_read_index, 23);
2921 
2922                 if (read_index < 0) {
2923                         adsp_dbg(buf->dsp, "Avail check on unstarted stream\n");
2924                         return 0;
2925                 }
2926 
2927                 buf->read_index = read_index;
2928         }
2929 
2930         ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(next_write_index),
2931                         &next_write_index);
2932         if (ret < 0)
2933                 return ret;
2934 
2935         write_index = sign_extend32(next_write_index, 23);
2936 
2937         avail = write_index - buf->read_index;
2938         if (avail < 0)
2939                 avail += wm_adsp_buffer_size(buf);
2940 
2941         adsp_dbg(buf->dsp, "readindex=0x%x, writeindex=0x%x, avail=%d\n",
2942                  buf->read_index, write_index, avail * WM_ADSP_DATA_WORD_SIZE);
2943 
2944         buf->avail = avail;
2945 
2946         return 0;
2947 }
2948 
2949 static int wm_adsp_buffer_get_error(struct wm_adsp_compr_buf *buf)
2950 {
2951         int ret;
2952 
2953         ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(error), &buf->error);
2954         if (ret < 0) {
2955                 adsp_err(buf->dsp, "Failed to check buffer error: %d\n", ret);
2956                 return ret;
2957         }
2958         if (buf->error != 0) {
2959                 adsp_err(buf->dsp, "Buffer error occurred: %d\n", buf->error);
2960                 return -EIO;
2961         }
2962 
2963         return 0;
2964 }
2965 
2966 int wm_adsp_compr_handle_irq(struct wm_adsp *dsp)
2967 {
2968         struct wm_adsp_compr_buf *buf;
2969         struct wm_adsp_compr *compr;
2970         int ret = 0;
2971 
2972         mutex_lock(&dsp->pwr_lock);
2973 
2974         buf = dsp->buffer;
2975         compr = dsp->compr;
2976 
2977         if (!buf) {
2978                 ret = -ENODEV;
2979                 goto out;
2980         }
2981 
2982         adsp_dbg(dsp, "Handling buffer IRQ\n");
2983 
2984         ret = wm_adsp_buffer_get_error(buf);
2985         if (ret < 0)
2986                 goto out_notify; /* Wake poll to report error */
2987 
2988         ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(irq_count),
2989                                   &buf->irq_count);
2990         if (ret < 0) {
2991                 adsp_err(dsp, "Failed to get irq_count: %d\n", ret);
2992                 goto out;
2993         }
2994 
2995         ret = wm_adsp_buffer_update_avail(buf);
2996         if (ret < 0) {
2997                 adsp_err(dsp, "Error reading avail: %d\n", ret);
2998                 goto out;
2999         }
3000 
3001 out_notify:
3002         if (compr && compr->stream)
3003                 snd_compr_fragment_elapsed(compr->stream);
3004 
3005 out:
3006         mutex_unlock(&dsp->pwr_lock);
3007 
3008         return ret;
3009 }
3010 EXPORT_SYMBOL_GPL(wm_adsp_compr_handle_irq);
3011 
3012 static int wm_adsp_buffer_reenable_irq(struct wm_adsp_compr_buf *buf)
3013 {
3014         if (buf->irq_count & 0x01)
3015                 return 0;
3016 
3017         adsp_dbg(buf->dsp, "Enable IRQ(0x%x) for next fragment\n",
3018                  buf->irq_count);
3019 
3020         buf->irq_count |= 0x01;
3021 
3022         return wm_adsp_buffer_write(buf, HOST_BUFFER_FIELD(irq_ack),
3023                                     buf->irq_count);
3024 }
3025 
3026 int wm_adsp_compr_pointer(struct snd_compr_stream *stream,
3027                           struct snd_compr_tstamp *tstamp)
3028 {
3029         struct wm_adsp_compr *compr = stream->runtime->private_data;
3030         struct wm_adsp *dsp = compr->dsp;
3031         struct wm_adsp_compr_buf *buf;
3032         int ret = 0;
3033 
3034         adsp_dbg(dsp, "Pointer request\n");
3035 
3036         mutex_lock(&dsp->pwr_lock);
3037 
3038         buf = compr->buf;
3039 
3040         if (!compr->buf) {
3041                 ret = -ENXIO;
3042                 goto out;
3043         }
3044 
3045         if (compr->buf->error) {
3046                 ret = -EIO;
3047                 goto out;
3048         }
3049 
3050         if (buf->avail < wm_adsp_compr_frag_words(compr)) {
3051                 ret = wm_adsp_buffer_update_avail(buf);
3052                 if (ret < 0) {
3053                         adsp_err(dsp, "Error reading avail: %d\n", ret);
3054                         goto out;
3055                 }
3056 
3057                 /*
3058                  * If we really have less than 1 fragment available tell the
3059                  * DSP to inform us once a whole fragment is available.
3060                  */
3061                 if (buf->avail < wm_adsp_compr_frag_words(compr)) {
3062                         ret = wm_adsp_buffer_get_error(buf);
3063                         if (ret < 0)
3064                                 goto out;
3065 
3066                         ret = wm_adsp_buffer_reenable_irq(buf);
3067                         if (ret < 0) {
3068                                 adsp_err(dsp,
3069                                          "Failed to re-enable buffer IRQ: %d\n",
3070                                          ret);
3071                                 goto out;
3072                         }
3073                 }
3074         }
3075 
3076         tstamp->copied_total = compr->copied_total;
3077         tstamp->copied_total += buf->avail * WM_ADSP_DATA_WORD_SIZE;
3078         tstamp->sampling_rate = compr->sample_rate;
3079 
3080 out:
3081         mutex_unlock(&dsp->pwr_lock);
3082 
3083         return ret;
3084 }
3085 EXPORT_SYMBOL_GPL(wm_adsp_compr_pointer);
3086 
3087 static int wm_adsp_buffer_capture_block(struct wm_adsp_compr *compr, int target)
3088 {
3089         struct wm_adsp_compr_buf *buf = compr->buf;
3090         u8 *pack_in = (u8 *)compr->raw_buf;
3091         u8 *pack_out = (u8 *)compr->raw_buf;
3092         unsigned int adsp_addr;
3093         int mem_type, nwords, max_read;
3094         int i, j, ret;
3095 
3096         /* Calculate read parameters */
3097         for (i = 0; i < wm_adsp_fw[buf->dsp->fw].caps->num_regions; ++i)
3098                 if (buf->read_index < buf->regions[i].cumulative_size)
3099                         break;
3100 
3101         if (i == wm_adsp_fw[buf->dsp->fw].caps->num_regions)
3102                 return -EINVAL;
3103 
3104         mem_type = buf->regions[i].mem_type;
3105         adsp_addr = buf->regions[i].base_addr +
3106                     (buf->read_index - buf->regions[i].offset);
3107 
3108         max_read = wm_adsp_compr_frag_words(compr);
3109         nwords = buf->regions[i].cumulative_size - buf->read_index;
3110 
3111         if (nwords > target)
3112                 nwords = target;
3113         if (nwords > buf->avail)
3114                 nwords = buf->avail;
3115         if (nwords > max_read)
3116                 nwords = max_read;
3117         if (!nwords)
3118                 return 0;
3119 
3120         /* Read data from DSP */
3121         ret = wm_adsp_read_data_block(buf->dsp, mem_type, adsp_addr,
3122                                       nwords, compr->raw_buf);
3123         if (ret < 0)
3124                 return ret;
3125 
3126         /* Remove the padding bytes from the data read from the DSP */
3127         for (i = 0; i < nwords; i++) {
3128                 for (j = 0; j < WM_ADSP_DATA_WORD_SIZE; j++)
3129                         *pack_out++ = *pack_in++;
3130 
3131                 pack_in += sizeof(*(compr->raw_buf)) - WM_ADSP_DATA_WORD_SIZE;
3132         }
3133 
3134         /* update read index to account for words read */
3135         buf->read_index += nwords;
3136         if (buf->read_index == wm_adsp_buffer_size(buf))
3137                 buf->read_index = 0;
3138 
3139         ret = wm_adsp_buffer_write(buf, HOST_BUFFER_FIELD(next_read_index),
3140                                    buf->read_index);
3141         if (ret < 0)
3142                 return ret;
3143 
3144         /* update avail to account for words read */
3145         buf->avail -= nwords;
3146 
3147         return nwords;
3148 }
3149 
3150 static int wm_adsp_compr_read(struct wm_adsp_compr *compr,
3151                               char __user *buf, size_t count)
3152 {
3153         struct wm_adsp *dsp = compr->dsp;
3154         int ntotal = 0;
3155         int nwords, nbytes;
3156 
3157         adsp_dbg(dsp, "Requested read of %zu bytes\n", count);
3158 
3159         if (!compr->buf)
3160                 return -ENXIO;
3161 
3162         if (compr->buf->error)
3163                 return -EIO;
3164 
3165         count /= WM_ADSP_DATA_WORD_SIZE;
3166 
3167         do {
3168                 nwords = wm_adsp_buffer_capture_block(compr, count);
3169                 if (nwords < 0) {
3170                         adsp_err(dsp, "Failed to capture block: %d\n", nwords);
3171                         return nwords;
3172                 }
3173 
3174                 nbytes = nwords * WM_ADSP_DATA_WORD_SIZE;
3175 
3176                 adsp_dbg(dsp, "Read %d bytes\n", nbytes);
3177 
3178                 if (copy_to_user(buf + ntotal, compr->raw_buf, nbytes)) {
3179                         adsp_err(dsp, "Failed to copy data to user: %d, %d\n",
3180                                  ntotal, nbytes);
3181                         return -EFAULT;
3182                 }
3183 
3184                 count -= nwords;
3185                 ntotal += nbytes;
3186         } while (nwords > 0 && count > 0);
3187 
3188         compr->copied_total += ntotal;
3189 
3190         return ntotal;
3191 }
3192 
3193 int wm_adsp_compr_copy(struct snd_compr_stream *stream, char __user *buf,
3194                        size_t count)
3195 {
3196         struct wm_adsp_compr *compr = stream->runtime->private_data;
3197         struct wm_adsp *dsp = compr->dsp;
3198         int ret;
3199 
3200         mutex_lock(&dsp->pwr_lock);
3201 
3202         if (stream->direction == SND_COMPRESS_CAPTURE)
3203                 ret = wm_adsp_compr_read(compr, buf, count);
3204         else
3205                 ret = -ENOTSUPP;
3206 
3207         mutex_unlock(&dsp->pwr_lock);
3208 
3209         return ret;
3210 }
3211 EXPORT_SYMBOL_GPL(wm_adsp_compr_copy);
3212 
3213 MODULE_LICENSE("GPL v2");
3214 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp