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 instantiated 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 instantiated 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