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