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