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
 27struct sst_mem_block;
 28struct sst_module;
 29struct 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 */
 37struct 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 */
 73struct 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	void __iomem *lpe;
 81	void __iomem *shim;
 82	void __iomem *pci_cfg;
 83	void __iomem *fw_ext;
 84};
 85
 86/*
 87 * Audio DSP Mailbox configuration.
 88 */
 89struct sst_mailbox {
 90	void __iomem *in_base;
 91	void __iomem *out_base;
 92	size_t in_size;
 93	size_t out_size;
 94};
 95
 96/*
 97 * Audio DSP memory block types.
 98 */
 99enum sst_mem_type {
100	SST_MEM_IRAM = 0,
101	SST_MEM_DRAM = 1,
102	SST_MEM_ANY  = 2,
103	SST_MEM_CACHE= 3,
104};
105
106/*
107 * Audio DSP Generic Firmware File.
108 *
109 * SST Firmware files can consist of 1..N modules. This generic structure is
110 * used to manage each firmware file and it's modules regardless of SST firmware
111 * type. A SST driver may load multiple FW files.
112 */
113struct sst_fw {
114	struct sst_dsp *dsp;
115
116	/* base addresses of FW file data */
117	dma_addr_t dmable_fw_paddr;	/* physical address of fw data */
118	void *dma_buf;			/* virtual address of fw data */
119	u32 size;			/* size of fw data */
120
121	/* lists */
122	struct list_head list;		/* DSP list of FW */
123	struct list_head module_list;	/* FW list of modules */
124
125	void *private;			/* core doesn't touch this */
126};
127
128/*
129 * Audio DSP Generic Module Template.
130 *
131 * Used to define and register a new FW module. This data is extracted from
132 * FW module header information.
133 */
134struct sst_module_template {
135	u32 id;
136	u32 entry;			/* entry point */
137	u32 scratch_size;
138	u32 persistent_size;
139};
140
141/*
142 * Block Allocator - Used to allocate blocks of DSP memory.
143 */
144struct sst_block_allocator {
145	u32 id;
146	u32 offset;
147	int size;
148	enum sst_mem_type type;
149};
150
151/*
152 * Runtime Module Instance - A module object can be instanciated multiple
153 * times within the DSP FW.
154 */
155struct sst_module_runtime {
156	struct sst_dsp *dsp;
157	int id;
158	struct sst_module *module;	/* parent module we belong too */
159
160	u32 persistent_offset;		/* private memory offset */
161	void *private;
162
163	struct list_head list;
164	struct list_head block_list;	/* list of blocks used */
165};
166
167/*
168 * Runtime Module Context - The runtime context must be manually stored by the
169 * driver prior to enter S3 and restored after leaving S3. This should really be
170 * part of the memory context saved by the enter D3 message IPC ???
171 */
172struct sst_module_runtime_context {
173	dma_addr_t dma_buffer;
174	u32 *buffer;
175};
176
177/*
178 * Audio DSP Module State
179 */
180enum sst_module_state {
181	SST_MODULE_STATE_UNLOADED = 0,	/* default state */
182	SST_MODULE_STATE_LOADED,
183	SST_MODULE_STATE_INITIALIZED,	/* and inactive */
184	SST_MODULE_STATE_ACTIVE,
185};
186
187/*
188 * Audio DSP Generic Module.
189 *
190 * Each Firmware file can consist of 1..N modules. A module can span multiple
191 * ADSP memory blocks. The simplest FW will be a file with 1 module. A module
192 * can be instanciated multiple times in the DSP.
193 */
194struct sst_module {
195	struct sst_dsp *dsp;
196	struct sst_fw *sst_fw;		/* parent FW we belong too */
197
198	/* module configuration */
199	u32 id;
200	u32 entry;			/* module entry point */
201	s32 offset;			/* module offset in firmware file */
202	u32 size;			/* module size */
203	u32 scratch_size;		/* global scratch memory required */
204	u32 persistent_size;		/* private memory required */
205	enum sst_mem_type type;		/* destination memory type */
206	u32 data_offset;		/* offset in ADSP memory space */
207	void *data;			/* module data */
208
209	/* runtime */
210	u32 usage_count;		/* can be unloaded if count == 0 */
211	void *private;			/* core doesn't touch this */
212
213	/* lists */
214	struct list_head block_list;	/* Module list of blocks in use */
215	struct list_head list;		/* DSP list of modules */
216	struct list_head list_fw;	/* FW list of modules */
217	struct list_head runtime_list;	/* list of runtime module objects*/
218
219	/* state */
220	enum sst_module_state state;
221};
222
223/*
224 * SST Memory Block operations.
225 */
226struct sst_block_ops {
227	int (*enable)(struct sst_mem_block *block);
228	int (*disable)(struct sst_mem_block *block);
229};
230
231/*
232 * SST Generic Memory Block.
233 *
234 * SST ADP  memory has multiple IRAM and DRAM blocks. Some ADSP blocks can be
235 * power gated.
236 */
237struct sst_mem_block {
238	struct sst_dsp *dsp;
239	struct sst_module *module;	/* module that uses this block */
240
241	/* block config */
242	u32 offset;			/* offset from base */
243	u32 size;			/* block size */
244	u32 index;			/* block index 0..N */
245	enum sst_mem_type type;		/* block memory type IRAM/DRAM */
246	const struct sst_block_ops *ops;/* block operations, if any */
247
248	/* block status */
249	u32 bytes_used;			/* bytes in use by modules */
250	void *private;			/* generic core does not touch this */
251	int users;			/* number of modules using this block */
252
253	/* block lists */
254	struct list_head module_list;	/* Module list of blocks */
255	struct list_head list;		/* Map list of free/used blocks */
256};
257
258/*
259 * Generic SST Shim Interface.
260 */
261struct sst_dsp {
262
263	/* Shared for all platforms */
264
265	/* runtime */
266	struct sst_dsp_device *sst_dev;
267	spinlock_t spinlock;	/* IPC locking */
268	struct mutex mutex;	/* DSP FW lock */
269	struct device *dev;
270	struct device *dma_dev;
271	void *thread_context;
272	int irq;
273	u32 id;
274
275	/* operations */
276	struct sst_ops *ops;
277
278	/* debug FS */
279	struct dentry *debugfs_root;
280
281	/* base addresses */
282	struct sst_addr addr;
283
284	/* mailbox */
285	struct sst_mailbox mailbox;
286
287	/* HSW/Byt data */
288
289	/* list of free and used ADSP memory blocks */
290	struct list_head used_block_list;
291	struct list_head free_block_list;
292
293	/* SST FW files loaded and their modules */
294	struct list_head module_list;
295	struct list_head fw_list;
296
297	/* scratch buffer */
298	struct list_head scratch_block_list;
299	u32 scratch_offset;
300	u32 scratch_size;
301
302	/* platform data */
303	struct sst_pdata *pdata;
304
305	/* DMA FW loading */
306	struct sst_dma *dma;
307	bool fw_use_dma;
308
309	/* SKL data */
310
311	const char *fw_name;
312
313	/* To allocate CL dma buffers */
314	struct skl_dsp_loader_ops dsp_ops;
315	struct skl_dsp_fw_ops fw_ops;
316	int sst_state;
317	struct skl_cl_dev cl_dev;
318	u32 intr_status;
319	const struct firmware *fw;
320	struct snd_dma_buffer dmab;
321};
322
323/* Size optimised DRAM/IRAM memcpy */
324static inline void sst_dsp_write(struct sst_dsp *sst, void *src,
325	u32 dest_offset, size_t bytes)
326{
327	sst->ops->ram_write(sst, sst->addr.lpe + dest_offset, src, bytes);
328}
329
330static inline void sst_dsp_read(struct sst_dsp *sst, void *dest,
331	u32 src_offset, size_t bytes)
332{
333	sst->ops->ram_read(sst, dest, sst->addr.lpe + src_offset, bytes);
334}
335
336static inline void *sst_dsp_get_thread_context(struct sst_dsp *sst)
337{
338	return sst->thread_context;
339}
340
341/* Create/Free FW files - can contain multiple modules */
342struct sst_fw *sst_fw_new(struct sst_dsp *dsp,
343	const struct firmware *fw, void *private);
344void sst_fw_free(struct sst_fw *sst_fw);
345void sst_fw_free_all(struct sst_dsp *dsp);
346int sst_fw_reload(struct sst_fw *sst_fw);
347void sst_fw_unload(struct sst_fw *sst_fw);
348
349/* Create/Free firmware modules */
350struct sst_module *sst_module_new(struct sst_fw *sst_fw,
351	struct sst_module_template *template, void *private);
352void sst_module_free(struct sst_module *module);
353struct sst_module *sst_module_get_from_id(struct sst_dsp *dsp, u32 id);
354int sst_module_alloc_blocks(struct sst_module *module);
355int sst_module_free_blocks(struct sst_module *module);
356
357/* Create/Free firmware module runtime instances */
358struct sst_module_runtime *sst_module_runtime_new(struct sst_module *module,
359	int id, void *private);
360void sst_module_runtime_free(struct sst_module_runtime *runtime);
361struct sst_module_runtime *sst_module_runtime_get_from_id(
362	struct sst_module *module, u32 id);
363int sst_module_runtime_alloc_blocks(struct sst_module_runtime *runtime,
364	int offset);
365int sst_module_runtime_free_blocks(struct sst_module_runtime *runtime);
366int sst_module_runtime_save(struct sst_module_runtime *runtime,
367	struct sst_module_runtime_context *context);
368int sst_module_runtime_restore(struct sst_module_runtime *runtime,
369	struct sst_module_runtime_context *context);
370
371/* generic block allocation */
372int sst_alloc_blocks(struct sst_dsp *dsp, struct sst_block_allocator *ba,
373	struct list_head *block_list);
374int sst_free_blocks(struct sst_dsp *dsp, struct list_head *block_list);
375
376/* scratch allocation */
377int sst_block_alloc_scratch(struct sst_dsp *dsp);
378void sst_block_free_scratch(struct sst_dsp *dsp);
379
380/* Register the DSPs memory blocks - would be nice to read from ACPI */
381struct sst_mem_block *sst_mem_block_register(struct sst_dsp *dsp, u32 offset,
382	u32 size, enum sst_mem_type type, const struct sst_block_ops *ops,
383	u32 index, void *private);
384void sst_mem_block_unregister_all(struct sst_dsp *dsp);
385
386u32 sst_dsp_get_offset(struct sst_dsp *dsp, u32 offset,
387	enum sst_mem_type type);
388#endif