1 /*
2  * Intel Smart Sound Technology
3  *
4  * Copyright (C) 2013, Intel Corporation. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License version
8  * 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16 
17 #ifndef __SOUND_SOC_SST_DSP_PRIV_H
18 #define __SOUND_SOC_SST_DSP_PRIV_H
19 
20 #include <linux/kernel.h>
21 #include <linux/types.h>
22 #include <linux/interrupt.h>
23 #include <linux/firmware.h>
24 
25 #include "../skylake/skl-sst-dsp.h"
26 
27 struct sst_mem_block;
28 struct sst_module;
29 struct sst_fw;
30 
31 /* do we need to remove or keep */
32 #define DSP_DRAM_ADDR_OFFSET		0x400000
33 
34 /*
35  * DSP Operations exported by platform Audio DSP driver.
36  */
37 struct sst_ops {
38 	/* DSP core boot / reset */
39 	void (*boot)(struct sst_dsp *);
40 	void (*reset)(struct sst_dsp *);
41 	int (*wake)(struct sst_dsp *);
42 	void (*sleep)(struct sst_dsp *);
43 	void (*stall)(struct sst_dsp *);
44 
45 	/* Shim IO */
46 	void (*write)(void __iomem *addr, u32 offset, u32 value);
47 	u32 (*read)(void __iomem *addr, u32 offset);
48 	void (*write64)(void __iomem *addr, u32 offset, u64 value);
49 	u64 (*read64)(void __iomem *addr, u32 offset);
50 
51 	/* DSP I/DRAM IO */
52 	void (*ram_read)(struct sst_dsp *sst, void  *dest, void __iomem *src,
53 		size_t bytes);
54 	void (*ram_write)(struct sst_dsp *sst, void __iomem *dest, void *src,
55 		size_t bytes);
56 
57 	void (*dump)(struct sst_dsp *);
58 
59 	/* IRQ handlers */
60 	irqreturn_t (*irq_handler)(int irq, void *context);
61 
62 	/* SST init and free */
63 	int (*init)(struct sst_dsp *sst, struct sst_pdata *pdata);
64 	void (*free)(struct sst_dsp *sst);
65 
66 	/* FW module parser/loader */
67 	int (*parse_fw)(struct sst_fw *sst_fw);
68 };
69 
70 /*
71  * Audio DSP memory offsets and addresses.
72  */
73 struct sst_addr {
74 	u32 lpe_base;
75 	u32 shim_offset;
76 	u32 iram_offset;
77 	u32 dram_offset;
78 	u32 dsp_iram_offset;
79 	u32 dsp_dram_offset;
80 	u32 sram0_base;
81 	u32 sram1_base;
82 	u32 w0_stat_sz;
83 	u32 w0_up_sz;
84 	void __iomem *lpe;
85 	void __iomem *shim;
86 	void __iomem *pci_cfg;
87 	void __iomem *fw_ext;
88 };
89 
90 /*
91  * Audio DSP Mailbox configuration.
92  */
93 struct sst_mailbox {
94 	void __iomem *in_base;
95 	void __iomem *out_base;
96 	size_t in_size;
97 	size_t out_size;
98 };
99 
100 /*
101  * Audio DSP memory block types.
102  */
103 enum sst_mem_type {
104 	SST_MEM_IRAM = 0,
105 	SST_MEM_DRAM = 1,
106 	SST_MEM_ANY  = 2,
107 	SST_MEM_CACHE= 3,
108 };
109 
110 /*
111  * Audio DSP Generic Firmware File.
112  *
113  * SST Firmware files can consist of 1..N modules. This generic structure is
114  * used to manage each firmware file and it's modules regardless of SST firmware
115  * type. A SST driver may load multiple FW files.
116  */
117 struct sst_fw {
118 	struct sst_dsp *dsp;
119 
120 	/* base addresses of FW file data */
121 	dma_addr_t dmable_fw_paddr;	/* physical address of fw data */
122 	void *dma_buf;			/* virtual address of fw data */
123 	u32 size;			/* size of fw data */
124 
125 	/* lists */
126 	struct list_head list;		/* DSP list of FW */
127 	struct list_head module_list;	/* FW list of modules */
128 
129 	void *private;			/* core doesn't touch this */
130 };
131 
132 /*
133  * Audio DSP Generic Module Template.
134  *
135  * Used to define and register a new FW module. This data is extracted from
136  * FW module header information.
137  */
138 struct sst_module_template {
139 	u32 id;
140 	u32 entry;			/* entry point */
141 	u32 scratch_size;
142 	u32 persistent_size;
143 };
144 
145 /*
146  * Block Allocator - Used to allocate blocks of DSP memory.
147  */
148 struct sst_block_allocator {
149 	u32 id;
150 	u32 offset;
151 	int size;
152 	enum sst_mem_type type;
153 };
154 
155 /*
156  * Runtime Module Instance - A module object can be instanciated multiple
157  * times within the DSP FW.
158  */
159 struct sst_module_runtime {
160 	struct sst_dsp *dsp;
161 	int id;
162 	struct sst_module *module;	/* parent module we belong too */
163 
164 	u32 persistent_offset;		/* private memory offset */
165 	void *private;
166 
167 	struct list_head list;
168 	struct list_head block_list;	/* list of blocks used */
169 };
170 
171 /*
172  * Runtime Module Context - The runtime context must be manually stored by the
173  * driver prior to enter S3 and restored after leaving S3. This should really be
174  * part of the memory context saved by the enter D3 message IPC ???
175  */
176 struct sst_module_runtime_context {
177 	dma_addr_t dma_buffer;
178 	u32 *buffer;
179 };
180 
181 /*
182  * Audio DSP Module State
183  */
184 enum sst_module_state {
185 	SST_MODULE_STATE_UNLOADED = 0,	/* default state */
186 	SST_MODULE_STATE_LOADED,
187 	SST_MODULE_STATE_INITIALIZED,	/* and inactive */
188 	SST_MODULE_STATE_ACTIVE,
189 };
190 
191 /*
192  * Audio DSP Generic Module.
193  *
194  * Each Firmware file can consist of 1..N modules. A module can span multiple
195  * ADSP memory blocks. The simplest FW will be a file with 1 module. A module
196  * can be instanciated multiple times in the DSP.
197  */
198 struct sst_module {
199 	struct sst_dsp *dsp;
200 	struct sst_fw *sst_fw;		/* parent FW we belong too */
201 
202 	/* module configuration */
203 	u32 id;
204 	u32 entry;			/* module entry point */
205 	s32 offset;			/* module offset in firmware file */
206 	u32 size;			/* module size */
207 	u32 scratch_size;		/* global scratch memory required */
208 	u32 persistent_size;		/* private memory required */
209 	enum sst_mem_type type;		/* destination memory type */
210 	u32 data_offset;		/* offset in ADSP memory space */
211 	void *data;			/* module data */
212 
213 	/* runtime */
214 	u32 usage_count;		/* can be unloaded if count == 0 */
215 	void *private;			/* core doesn't touch this */
216 
217 	/* lists */
218 	struct list_head block_list;	/* Module list of blocks in use */
219 	struct list_head list;		/* DSP list of modules */
220 	struct list_head list_fw;	/* FW list of modules */
221 	struct list_head runtime_list;	/* list of runtime module objects*/
222 
223 	/* state */
224 	enum sst_module_state state;
225 };
226 
227 /*
228  * SST Memory Block operations.
229  */
230 struct sst_block_ops {
231 	int (*enable)(struct sst_mem_block *block);
232 	int (*disable)(struct sst_mem_block *block);
233 };
234 
235 /*
236  * SST Generic Memory Block.
237  *
238  * SST ADP  memory has multiple IRAM and DRAM blocks. Some ADSP blocks can be
239  * power gated.
240  */
241 struct sst_mem_block {
242 	struct sst_dsp *dsp;
243 	struct sst_module *module;	/* module that uses this block */
244 
245 	/* block config */
246 	u32 offset;			/* offset from base */
247 	u32 size;			/* block size */
248 	u32 index;			/* block index 0..N */
249 	enum sst_mem_type type;		/* block memory type IRAM/DRAM */
250 	const struct sst_block_ops *ops;/* block operations, if any */
251 
252 	/* block status */
253 	u32 bytes_used;			/* bytes in use by modules */
254 	void *private;			/* generic core does not touch this */
255 	int users;			/* number of modules using this block */
256 
257 	/* block lists */
258 	struct list_head module_list;	/* Module list of blocks */
259 	struct list_head list;		/* Map list of free/used blocks */
260 };
261 
262 /*
263  * Generic SST Shim Interface.
264  */
265 struct sst_dsp {
266 
267 	/* Shared for all platforms */
268 
269 	/* runtime */
270 	struct sst_dsp_device *sst_dev;
271 	spinlock_t spinlock;	/* IPC locking */
272 	struct mutex mutex;	/* DSP FW lock */
273 	struct device *dev;
274 	struct device *dma_dev;
275 	void *thread_context;
276 	int irq;
277 	u32 id;
278 
279 	/* operations */
280 	struct sst_ops *ops;
281 
282 	/* debug FS */
283 	struct dentry *debugfs_root;
284 
285 	/* base addresses */
286 	struct sst_addr addr;
287 
288 	/* mailbox */
289 	struct sst_mailbox mailbox;
290 
291 	/* HSW/Byt data */
292 
293 	/* list of free and used ADSP memory blocks */
294 	struct list_head used_block_list;
295 	struct list_head free_block_list;
296 
297 	/* SST FW files loaded and their modules */
298 	struct list_head module_list;
299 	struct list_head fw_list;
300 
301 	/* scratch buffer */
302 	struct list_head scratch_block_list;
303 	u32 scratch_offset;
304 	u32 scratch_size;
305 
306 	/* platform data */
307 	struct sst_pdata *pdata;
308 
309 	/* DMA FW loading */
310 	struct sst_dma *dma;
311 	bool fw_use_dma;
312 
313 	/* SKL data */
314 
315 	const char *fw_name;
316 
317 	/* To allocate CL dma buffers */
318 	struct skl_dsp_loader_ops dsp_ops;
319 	struct skl_dsp_fw_ops fw_ops;
320 	int sst_state;
321 	struct skl_cl_dev cl_dev;
322 	u32 intr_status;
323 	const struct firmware *fw;
324 	struct snd_dma_buffer dmab;
325 };
326 
327 /* Size optimised DRAM/IRAM memcpy */
328 static inline void sst_dsp_write(struct sst_dsp *sst, void *src,
329 	u32 dest_offset, size_t bytes)
330 {
331 	sst->ops->ram_write(sst, sst->addr.lpe + dest_offset, src, bytes);
332 }
333 
334 static inline void sst_dsp_read(struct sst_dsp *sst, void *dest,
335 	u32 src_offset, size_t bytes)
336 {
337 	sst->ops->ram_read(sst, dest, sst->addr.lpe + src_offset, bytes);
338 }
339 
340 static inline void *sst_dsp_get_thread_context(struct sst_dsp *sst)
341 {
342 	return sst->thread_context;
343 }
344 
345 /* Create/Free FW files - can contain multiple modules */
346 struct sst_fw *sst_fw_new(struct sst_dsp *dsp,
347 	const struct firmware *fw, void *private);
348 void sst_fw_free(struct sst_fw *sst_fw);
349 void sst_fw_free_all(struct sst_dsp *dsp);
350 int sst_fw_reload(struct sst_fw *sst_fw);
351 void sst_fw_unload(struct sst_fw *sst_fw);
352 
353 /* Create/Free firmware modules */
354 struct sst_module *sst_module_new(struct sst_fw *sst_fw,
355 	struct sst_module_template *template, void *private);
356 void sst_module_free(struct sst_module *module);
357 struct sst_module *sst_module_get_from_id(struct sst_dsp *dsp, u32 id);
358 int sst_module_alloc_blocks(struct sst_module *module);
359 int sst_module_free_blocks(struct sst_module *module);
360 
361 /* Create/Free firmware module runtime instances */
362 struct sst_module_runtime *sst_module_runtime_new(struct sst_module *module,
363 	int id, void *private);
364 void sst_module_runtime_free(struct sst_module_runtime *runtime);
365 struct sst_module_runtime *sst_module_runtime_get_from_id(
366 	struct sst_module *module, u32 id);
367 int sst_module_runtime_alloc_blocks(struct sst_module_runtime *runtime,
368 	int offset);
369 int sst_module_runtime_free_blocks(struct sst_module_runtime *runtime);
370 int sst_module_runtime_save(struct sst_module_runtime *runtime,
371 	struct sst_module_runtime_context *context);
372 int sst_module_runtime_restore(struct sst_module_runtime *runtime,
373 	struct sst_module_runtime_context *context);
374 
375 /* generic block allocation */
376 int sst_alloc_blocks(struct sst_dsp *dsp, struct sst_block_allocator *ba,
377 	struct list_head *block_list);
378 int sst_free_blocks(struct sst_dsp *dsp, struct list_head *block_list);
379 
380 /* scratch allocation */
381 int sst_block_alloc_scratch(struct sst_dsp *dsp);
382 void sst_block_free_scratch(struct sst_dsp *dsp);
383 
384 /* Register the DSPs memory blocks - would be nice to read from ACPI */
385 struct sst_mem_block *sst_mem_block_register(struct sst_dsp *dsp, u32 offset,
386 	u32 size, enum sst_mem_type type, const struct sst_block_ops *ops,
387 	u32 index, void *private);
388 void sst_mem_block_unregister_all(struct sst_dsp *dsp);
389 
390 u32 sst_dsp_get_offset(struct sst_dsp *dsp, u32 offset,
391 	enum sst_mem_type type);
392 #endif
393