root/sound/soc/intel/common/sst-dsp-priv.h

INCLUDED FROM

DEFINITIONS

1. sst_dsp_write
2. sst_dsp_read
3. sst_dsp_get_thread_context

   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