2 * Intel SST Firmware Loader
4 * Copyright (C) 2013, Intel Corporation. All rights reserved.
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.
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.
17 #include <linux/kernel.h>
18 #include <linux/slab.h>
19 #include <linux/sched.h>
20 #include <linux/firmware.h>
21 #include <linux/export.h>
22 #include <linux/platform_device.h>
23 #include <linux/dma-mapping.h>
24 #include <linux/dmaengine.h>
25 #include <linux/pci.h>
26 #include <linux/acpi.h>
28 /* supported DMA engine drivers */
29 #include <linux/dma/dw.h>
32 #include <asm/pgtable.h>
35 #include "sst-dsp-priv.h"
37 #define SST_DMA_RESOURCES 2
38 #define SST_DSP_DMA_MAX_BURST 0x3
39 #define SST_HSW_BLOCK_ANY 0xffffffff
41 #define SST_HSW_MASK_DMA_ADDR_DSP 0xfff00000
46 struct dw_dma_chip *chip;
48 struct dma_async_tx_descriptor *desc;
52 static inline void sst_memcpy32(volatile void __iomem *dest, void *src, u32 bytes)
56 const u8 *src_byte = src;
61 /* __iowrite32_copy use 32bit size values so divide by 4 */
62 __iowrite32_copy((void *)dest, src, m);
65 for (i = 0; i < n; i++)
66 tmp |= (u32)*(src_byte + m * 4 + i) << (i * 8);
67 __iowrite32_copy((void *)(dest + m * 4), &tmp, 1);
72 static void sst_dma_transfer_complete(void *arg)
74 struct sst_dsp *sst = (struct sst_dsp *)arg;
76 dev_dbg(sst->dev, "DMA: callback\n");
79 static int sst_dsp_dma_copy(struct sst_dsp *sst, dma_addr_t dest_addr,
80 dma_addr_t src_addr, size_t size)
82 struct dma_async_tx_descriptor *desc;
83 struct sst_dma *dma = sst->dma;
85 if (dma->ch == NULL) {
86 dev_err(sst->dev, "error: no DMA channel\n");
90 dev_dbg(sst->dev, "DMA: src: 0x%lx dest 0x%lx size %zu\n",
91 (unsigned long)src_addr, (unsigned long)dest_addr, size);
93 desc = dma->ch->device->device_prep_dma_memcpy(dma->ch, dest_addr,
94 src_addr, size, DMA_CTRL_ACK);
96 dev_err(sst->dev, "error: dma prep memcpy failed\n");
100 desc->callback = sst_dma_transfer_complete;
101 desc->callback_param = sst;
103 desc->tx_submit(desc);
104 dma_wait_for_async_tx(desc);
110 int sst_dsp_dma_copyto(struct sst_dsp *sst, dma_addr_t dest_addr,
111 dma_addr_t src_addr, size_t size)
113 return sst_dsp_dma_copy(sst, dest_addr | SST_HSW_MASK_DMA_ADDR_DSP,
116 EXPORT_SYMBOL_GPL(sst_dsp_dma_copyto);
119 int sst_dsp_dma_copyfrom(struct sst_dsp *sst, dma_addr_t dest_addr,
120 dma_addr_t src_addr, size_t size)
122 return sst_dsp_dma_copy(sst, dest_addr,
123 src_addr | SST_HSW_MASK_DMA_ADDR_DSP, size);
125 EXPORT_SYMBOL_GPL(sst_dsp_dma_copyfrom);
127 /* remove module from memory - callers hold locks */
128 static void block_list_remove(struct sst_dsp *dsp,
129 struct list_head *block_list)
131 struct sst_mem_block *block, *tmp;
134 /* disable each block */
135 list_for_each_entry(block, block_list, module_list) {
137 if (block->ops && block->ops->disable) {
138 err = block->ops->disable(block);
141 "error: cant disable block %d:%d\n",
142 block->type, block->index);
146 /* mark each block as free */
147 list_for_each_entry_safe(block, tmp, block_list, module_list) {
148 list_del(&block->module_list);
149 list_move(&block->list, &dsp->free_block_list);
150 dev_dbg(dsp->dev, "block freed %d:%d at offset 0x%x\n",
151 block->type, block->index, block->offset);
155 /* prepare the memory block to receive data from host - callers hold locks */
156 static int block_list_prepare(struct sst_dsp *dsp,
157 struct list_head *block_list)
159 struct sst_mem_block *block;
162 /* enable each block so that's it'e ready for data */
163 list_for_each_entry(block, block_list, module_list) {
165 if (block->ops && block->ops->enable && !block->users) {
166 ret = block->ops->enable(block);
169 "error: cant disable block %d:%d\n",
170 block->type, block->index);
178 list_for_each_entry(block, block_list, module_list) {
179 if (block->ops && block->ops->disable)
180 block->ops->disable(block);
185 static struct dw_dma_chip *dw_probe(struct device *dev, struct resource *mem,
188 struct dw_dma_chip *chip;
191 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
193 return ERR_PTR(-ENOMEM);
196 chip->regs = devm_ioremap_resource(dev, mem);
197 if (IS_ERR(chip->regs))
198 return ERR_CAST(chip->regs);
200 err = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(31));
206 err = dw_dma_probe(chip);
213 static void dw_remove(struct dw_dma_chip *chip)
218 static bool dma_chan_filter(struct dma_chan *chan, void *param)
220 struct sst_dsp *dsp = (struct sst_dsp *)param;
222 return chan->device->dev == dsp->dma_dev;
225 int sst_dsp_dma_get_channel(struct sst_dsp *dsp, int chan_id)
227 struct sst_dma *dma = dsp->dma;
228 struct dma_slave_config slave;
233 dma_cap_set(DMA_SLAVE, mask);
234 dma_cap_set(DMA_MEMCPY, mask);
236 dma->ch = dma_request_channel(mask, dma_chan_filter, dsp);
237 if (dma->ch == NULL) {
238 dev_err(dsp->dev, "error: DMA request channel failed\n");
242 memset(&slave, 0, sizeof(slave));
243 slave.direction = DMA_MEM_TO_DEV;
244 slave.src_addr_width =
245 slave.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
246 slave.src_maxburst = slave.dst_maxburst = SST_DSP_DMA_MAX_BURST;
248 ret = dmaengine_slave_config(dma->ch, &slave);
250 dev_err(dsp->dev, "error: unable to set DMA slave config %d\n",
252 dma_release_channel(dma->ch);
258 EXPORT_SYMBOL_GPL(sst_dsp_dma_get_channel);
260 void sst_dsp_dma_put_channel(struct sst_dsp *dsp)
262 struct sst_dma *dma = dsp->dma;
267 dma_release_channel(dma->ch);
270 EXPORT_SYMBOL_GPL(sst_dsp_dma_put_channel);
272 int sst_dma_new(struct sst_dsp *sst)
274 struct sst_pdata *sst_pdata = sst->pdata;
279 if (sst->pdata->resindex_dma_base == -1)
280 /* DMA is not used, return and squelsh error messages */
283 /* configure the correct platform data for whatever DMA engine
284 * is attached to the ADSP IP. */
285 switch (sst->pdata->dma_engine) {
286 case SST_DMA_TYPE_DW:
289 dev_err(sst->dev, "error: invalid DMA engine %d\n",
290 sst->pdata->dma_engine);
294 dma = devm_kzalloc(sst->dev, sizeof(struct sst_dma), GFP_KERNEL);
300 memset(&mem, 0, sizeof(mem));
302 mem.start = sst->addr.lpe_base + sst_pdata->dma_base;
303 mem.end = sst->addr.lpe_base + sst_pdata->dma_base + sst_pdata->dma_size - 1;
304 mem.flags = IORESOURCE_MEM;
306 /* now register DMA engine device */
307 dma->chip = dw_probe(sst->dma_dev, &mem, sst_pdata->irq);
308 if (IS_ERR(dma->chip)) {
309 dev_err(sst->dev, "error: DMA device register failed\n");
310 ret = PTR_ERR(dma->chip);
315 sst->fw_use_dma = true;
319 devm_kfree(sst->dev, dma);
322 EXPORT_SYMBOL(sst_dma_new);
324 void sst_dma_free(struct sst_dma *dma)
331 dma_release_channel(dma->ch);
334 dw_remove(dma->chip);
337 EXPORT_SYMBOL(sst_dma_free);
339 /* create new generic firmware object */
340 struct sst_fw *sst_fw_new(struct sst_dsp *dsp,
341 const struct firmware *fw, void *private)
343 struct sst_fw *sst_fw;
346 if (!dsp->ops->parse_fw)
349 sst_fw = kzalloc(sizeof(*sst_fw), GFP_KERNEL);
354 sst_fw->private = private;
355 sst_fw->size = fw->size;
357 /* allocate DMA buffer to store FW data */
358 sst_fw->dma_buf = dma_alloc_coherent(dsp->dma_dev, sst_fw->size,
359 &sst_fw->dmable_fw_paddr, GFP_DMA | GFP_KERNEL);
360 if (!sst_fw->dma_buf) {
361 dev_err(dsp->dev, "error: DMA alloc failed\n");
366 /* copy FW data to DMA-able memory */
367 memcpy((void *)sst_fw->dma_buf, (void *)fw->data, fw->size);
369 if (dsp->fw_use_dma) {
370 err = sst_dsp_dma_get_channel(dsp, 0);
375 /* call core specific FW paser to load FW data into DSP */
376 err = dsp->ops->parse_fw(sst_fw);
378 dev_err(dsp->dev, "error: parse fw failed %d\n", err);
383 sst_dsp_dma_put_channel(dsp);
385 mutex_lock(&dsp->mutex);
386 list_add(&sst_fw->list, &dsp->fw_list);
387 mutex_unlock(&dsp->mutex);
393 sst_dsp_dma_put_channel(dsp);
395 dma_free_coherent(dsp->dma_dev, sst_fw->size,
397 sst_fw->dmable_fw_paddr);
398 sst_fw->dma_buf = NULL;
402 EXPORT_SYMBOL_GPL(sst_fw_new);
404 int sst_fw_reload(struct sst_fw *sst_fw)
406 struct sst_dsp *dsp = sst_fw->dsp;
409 dev_dbg(dsp->dev, "reloading firmware\n");
411 /* call core specific FW paser to load FW data into DSP */
412 ret = dsp->ops->parse_fw(sst_fw);
414 dev_err(dsp->dev, "error: parse fw failed %d\n", ret);
418 EXPORT_SYMBOL_GPL(sst_fw_reload);
420 void sst_fw_unload(struct sst_fw *sst_fw)
422 struct sst_dsp *dsp = sst_fw->dsp;
423 struct sst_module *module, *mtmp;
424 struct sst_module_runtime *runtime, *rtmp;
426 dev_dbg(dsp->dev, "unloading firmware\n");
428 mutex_lock(&dsp->mutex);
430 /* check module by module */
431 list_for_each_entry_safe(module, mtmp, &dsp->module_list, list) {
432 if (module->sst_fw == sst_fw) {
434 /* remove runtime modules */
435 list_for_each_entry_safe(runtime, rtmp, &module->runtime_list, list) {
437 block_list_remove(dsp, &runtime->block_list);
438 list_del(&runtime->list);
442 /* now remove the module */
443 block_list_remove(dsp, &module->block_list);
444 list_del(&module->list);
449 /* remove all scratch blocks */
450 block_list_remove(dsp, &dsp->scratch_block_list);
452 mutex_unlock(&dsp->mutex);
454 EXPORT_SYMBOL_GPL(sst_fw_unload);
456 /* free single firmware object */
457 void sst_fw_free(struct sst_fw *sst_fw)
459 struct sst_dsp *dsp = sst_fw->dsp;
461 mutex_lock(&dsp->mutex);
462 list_del(&sst_fw->list);
463 mutex_unlock(&dsp->mutex);
466 dma_free_coherent(dsp->dma_dev, sst_fw->size, sst_fw->dma_buf,
467 sst_fw->dmable_fw_paddr);
470 EXPORT_SYMBOL_GPL(sst_fw_free);
472 /* free all firmware objects */
473 void sst_fw_free_all(struct sst_dsp *dsp)
475 struct sst_fw *sst_fw, *t;
477 mutex_lock(&dsp->mutex);
478 list_for_each_entry_safe(sst_fw, t, &dsp->fw_list, list) {
480 list_del(&sst_fw->list);
481 dma_free_coherent(dsp->dev, sst_fw->size, sst_fw->dma_buf,
482 sst_fw->dmable_fw_paddr);
485 mutex_unlock(&dsp->mutex);
487 EXPORT_SYMBOL_GPL(sst_fw_free_all);
489 /* create a new SST generic module from FW template */
490 struct sst_module *sst_module_new(struct sst_fw *sst_fw,
491 struct sst_module_template *template, void *private)
493 struct sst_dsp *dsp = sst_fw->dsp;
494 struct sst_module *sst_module;
496 sst_module = kzalloc(sizeof(*sst_module), GFP_KERNEL);
497 if (sst_module == NULL)
500 sst_module->id = template->id;
501 sst_module->dsp = dsp;
502 sst_module->sst_fw = sst_fw;
503 sst_module->scratch_size = template->scratch_size;
504 sst_module->persistent_size = template->persistent_size;
505 sst_module->entry = template->entry;
506 sst_module->state = SST_MODULE_STATE_UNLOADED;
508 INIT_LIST_HEAD(&sst_module->block_list);
509 INIT_LIST_HEAD(&sst_module->runtime_list);
511 mutex_lock(&dsp->mutex);
512 list_add(&sst_module->list, &dsp->module_list);
513 mutex_unlock(&dsp->mutex);
517 EXPORT_SYMBOL_GPL(sst_module_new);
519 /* free firmware module and remove from available list */
520 void sst_module_free(struct sst_module *sst_module)
522 struct sst_dsp *dsp = sst_module->dsp;
524 mutex_lock(&dsp->mutex);
525 list_del(&sst_module->list);
526 mutex_unlock(&dsp->mutex);
530 EXPORT_SYMBOL_GPL(sst_module_free);
532 struct sst_module_runtime *sst_module_runtime_new(struct sst_module *module,
533 int id, void *private)
535 struct sst_dsp *dsp = module->dsp;
536 struct sst_module_runtime *runtime;
538 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
544 runtime->module = module;
545 INIT_LIST_HEAD(&runtime->block_list);
547 mutex_lock(&dsp->mutex);
548 list_add(&runtime->list, &module->runtime_list);
549 mutex_unlock(&dsp->mutex);
553 EXPORT_SYMBOL_GPL(sst_module_runtime_new);
555 void sst_module_runtime_free(struct sst_module_runtime *runtime)
557 struct sst_dsp *dsp = runtime->dsp;
559 mutex_lock(&dsp->mutex);
560 list_del(&runtime->list);
561 mutex_unlock(&dsp->mutex);
565 EXPORT_SYMBOL_GPL(sst_module_runtime_free);
567 static struct sst_mem_block *find_block(struct sst_dsp *dsp,
568 struct sst_block_allocator *ba)
570 struct sst_mem_block *block;
572 list_for_each_entry(block, &dsp->free_block_list, list) {
573 if (block->type == ba->type && block->offset == ba->offset)
580 /* Block allocator must be on block boundary */
581 static int block_alloc_contiguous(struct sst_dsp *dsp,
582 struct sst_block_allocator *ba, struct list_head *block_list)
584 struct list_head tmp = LIST_HEAD_INIT(tmp);
585 struct sst_mem_block *block;
586 u32 block_start = SST_HSW_BLOCK_ANY;
587 int size = ba->size, offset = ba->offset;
589 while (ba->size > 0) {
591 block = find_block(dsp, ba);
593 list_splice(&tmp, &dsp->free_block_list);
600 list_move_tail(&block->list, &tmp);
601 ba->offset += block->size;
602 ba->size -= block->size;
607 list_for_each_entry(block, &tmp, list) {
609 if (block->offset < block_start)
610 block_start = block->offset;
612 list_add(&block->module_list, block_list);
614 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
615 block->type, block->index, block->offset);
618 list_splice(&tmp, &dsp->used_block_list);
622 /* allocate first free DSP blocks for data - callers hold locks */
623 static int block_alloc(struct sst_dsp *dsp, struct sst_block_allocator *ba,
624 struct list_head *block_list)
626 struct sst_mem_block *block, *tmp;
632 /* find first free whole blocks that can hold module */
633 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
635 /* ignore blocks with wrong type */
636 if (block->type != ba->type)
639 if (ba->size > block->size)
642 ba->offset = block->offset;
643 block->bytes_used = ba->size % block->size;
644 list_add(&block->module_list, block_list);
645 list_move(&block->list, &dsp->used_block_list);
646 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
647 block->type, block->index, block->offset);
651 /* then find free multiple blocks that can hold module */
652 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
654 /* ignore blocks with wrong type */
655 if (block->type != ba->type)
658 /* do we span > 1 blocks */
659 if (ba->size > block->size) {
661 /* align ba to block boundary */
662 ba->offset = block->offset;
664 ret = block_alloc_contiguous(dsp, ba, block_list);
671 /* not enough free block space */
675 int sst_alloc_blocks(struct sst_dsp *dsp, struct sst_block_allocator *ba,
676 struct list_head *block_list)
680 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n",
681 ba->size, ba->offset, ba->type);
683 mutex_lock(&dsp->mutex);
685 ret = block_alloc(dsp, ba, block_list);
687 dev_err(dsp->dev, "error: can't alloc blocks %d\n", ret);
691 /* prepare DSP blocks for module usage */
692 ret = block_list_prepare(dsp, block_list);
694 dev_err(dsp->dev, "error: prepare failed\n");
697 mutex_unlock(&dsp->mutex);
700 EXPORT_SYMBOL_GPL(sst_alloc_blocks);
702 int sst_free_blocks(struct sst_dsp *dsp, struct list_head *block_list)
704 mutex_lock(&dsp->mutex);
705 block_list_remove(dsp, block_list);
706 mutex_unlock(&dsp->mutex);
709 EXPORT_SYMBOL_GPL(sst_free_blocks);
711 /* allocate memory blocks for static module addresses - callers hold locks */
712 static int block_alloc_fixed(struct sst_dsp *dsp, struct sst_block_allocator *ba,
713 struct list_head *block_list)
715 struct sst_mem_block *block, *tmp;
716 struct sst_block_allocator ba_tmp = *ba;
717 u32 end = ba->offset + ba->size, block_end;
720 /* only IRAM/DRAM blocks are managed */
721 if (ba->type != SST_MEM_IRAM && ba->type != SST_MEM_DRAM)
724 /* are blocks already attached to this module */
725 list_for_each_entry_safe(block, tmp, block_list, module_list) {
727 /* ignore blocks with wrong type */
728 if (block->type != ba->type)
731 block_end = block->offset + block->size;
733 /* find block that holds section */
734 if (ba->offset >= block->offset && end <= block_end)
737 /* does block span more than 1 section */
738 if (ba->offset >= block->offset && ba->offset < block_end) {
740 /* align ba to block boundary */
741 ba_tmp.size -= block_end - ba->offset;
742 ba_tmp.offset = block_end;
743 err = block_alloc_contiguous(dsp, &ba_tmp, block_list);
747 /* module already owns blocks */
752 /* find first free blocks that can hold section in free list */
753 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
754 block_end = block->offset + block->size;
756 /* ignore blocks with wrong type */
757 if (block->type != ba->type)
760 /* find block that holds section */
761 if (ba->offset >= block->offset && end <= block_end) {
764 list_move(&block->list, &dsp->used_block_list);
765 list_add(&block->module_list, block_list);
766 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
767 block->type, block->index, block->offset);
771 /* does block span more than 1 section */
772 if (ba->offset >= block->offset && ba->offset < block_end) {
775 list_move(&block->list, &dsp->used_block_list);
776 list_add(&block->module_list, block_list);
777 /* align ba to block boundary */
778 ba_tmp.size -= block_end - ba->offset;
779 ba_tmp.offset = block_end;
781 err = block_alloc_contiguous(dsp, &ba_tmp, block_list);
792 /* Load fixed module data into DSP memory blocks */
793 int sst_module_alloc_blocks(struct sst_module *module)
795 struct sst_dsp *dsp = module->dsp;
796 struct sst_fw *sst_fw = module->sst_fw;
797 struct sst_block_allocator ba;
800 memset(&ba, 0, sizeof(ba));
801 ba.size = module->size;
802 ba.type = module->type;
803 ba.offset = module->offset;
805 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n",
806 ba.size, ba.offset, ba.type);
808 mutex_lock(&dsp->mutex);
810 /* alloc blocks that includes this section */
811 ret = block_alloc_fixed(dsp, &ba, &module->block_list);
814 "error: no free blocks for section at offset 0x%x size 0x%x\n",
815 module->offset, module->size);
816 mutex_unlock(&dsp->mutex);
820 /* prepare DSP blocks for module copy */
821 ret = block_list_prepare(dsp, &module->block_list);
823 dev_err(dsp->dev, "error: fw module prepare failed\n");
827 /* copy partial module data to blocks */
828 if (dsp->fw_use_dma) {
829 ret = sst_dsp_dma_copyto(dsp,
830 dsp->addr.lpe_base + module->offset,
831 sst_fw->dmable_fw_paddr + module->data_offset,
834 dev_err(dsp->dev, "error: module copy failed\n");
838 sst_memcpy32(dsp->addr.lpe + module->offset, module->data,
841 mutex_unlock(&dsp->mutex);
845 block_list_remove(dsp, &module->block_list);
846 mutex_unlock(&dsp->mutex);
849 EXPORT_SYMBOL_GPL(sst_module_alloc_blocks);
851 /* Unload entire module from DSP memory */
852 int sst_module_free_blocks(struct sst_module *module)
854 struct sst_dsp *dsp = module->dsp;
856 mutex_lock(&dsp->mutex);
857 block_list_remove(dsp, &module->block_list);
858 mutex_unlock(&dsp->mutex);
861 EXPORT_SYMBOL_GPL(sst_module_free_blocks);
863 int sst_module_runtime_alloc_blocks(struct sst_module_runtime *runtime,
866 struct sst_dsp *dsp = runtime->dsp;
867 struct sst_module *module = runtime->module;
868 struct sst_block_allocator ba;
871 if (module->persistent_size == 0)
874 memset(&ba, 0, sizeof(ba));
875 ba.size = module->persistent_size;
876 ba.type = SST_MEM_DRAM;
878 mutex_lock(&dsp->mutex);
880 /* do we need to allocate at a fixed address ? */
885 dev_dbg(dsp->dev, "persistent fixed block request 0x%x bytes type %d offset 0x%x\n",
886 ba.size, ba.type, ba.offset);
888 /* alloc blocks that includes this section */
889 ret = block_alloc_fixed(dsp, &ba, &runtime->block_list);
892 dev_dbg(dsp->dev, "persistent block request 0x%x bytes type %d\n",
895 /* alloc blocks that includes this section */
896 ret = block_alloc(dsp, &ba, &runtime->block_list);
900 "error: no free blocks for runtime module size 0x%x\n",
901 module->persistent_size);
902 mutex_unlock(&dsp->mutex);
905 runtime->persistent_offset = ba.offset;
907 /* prepare DSP blocks for module copy */
908 ret = block_list_prepare(dsp, &runtime->block_list);
910 dev_err(dsp->dev, "error: runtime block prepare failed\n");
914 mutex_unlock(&dsp->mutex);
918 block_list_remove(dsp, &module->block_list);
919 mutex_unlock(&dsp->mutex);
922 EXPORT_SYMBOL_GPL(sst_module_runtime_alloc_blocks);
924 int sst_module_runtime_free_blocks(struct sst_module_runtime *runtime)
926 struct sst_dsp *dsp = runtime->dsp;
928 mutex_lock(&dsp->mutex);
929 block_list_remove(dsp, &runtime->block_list);
930 mutex_unlock(&dsp->mutex);
933 EXPORT_SYMBOL_GPL(sst_module_runtime_free_blocks);
935 int sst_module_runtime_save(struct sst_module_runtime *runtime,
936 struct sst_module_runtime_context *context)
938 struct sst_dsp *dsp = runtime->dsp;
939 struct sst_module *module = runtime->module;
942 dev_dbg(dsp->dev, "saving runtime %d memory at 0x%x size 0x%x\n",
943 runtime->id, runtime->persistent_offset,
944 module->persistent_size);
946 context->buffer = dma_alloc_coherent(dsp->dma_dev,
947 module->persistent_size,
948 &context->dma_buffer, GFP_DMA | GFP_KERNEL);
949 if (!context->buffer) {
950 dev_err(dsp->dev, "error: DMA context alloc failed\n");
954 mutex_lock(&dsp->mutex);
956 if (dsp->fw_use_dma) {
958 ret = sst_dsp_dma_get_channel(dsp, 0);
962 ret = sst_dsp_dma_copyfrom(dsp, context->dma_buffer,
963 dsp->addr.lpe_base + runtime->persistent_offset,
964 module->persistent_size);
965 sst_dsp_dma_put_channel(dsp);
967 dev_err(dsp->dev, "error: context copy failed\n");
971 sst_memcpy32(context->buffer, dsp->addr.lpe +
972 runtime->persistent_offset,
973 module->persistent_size);
976 mutex_unlock(&dsp->mutex);
979 EXPORT_SYMBOL_GPL(sst_module_runtime_save);
981 int sst_module_runtime_restore(struct sst_module_runtime *runtime,
982 struct sst_module_runtime_context *context)
984 struct sst_dsp *dsp = runtime->dsp;
985 struct sst_module *module = runtime->module;
988 dev_dbg(dsp->dev, "restoring runtime %d memory at 0x%x size 0x%x\n",
989 runtime->id, runtime->persistent_offset,
990 module->persistent_size);
992 mutex_lock(&dsp->mutex);
994 if (!context->buffer) {
995 dev_info(dsp->dev, "no context buffer need to restore!\n");
999 if (dsp->fw_use_dma) {
1001 ret = sst_dsp_dma_get_channel(dsp, 0);
1005 ret = sst_dsp_dma_copyto(dsp,
1006 dsp->addr.lpe_base + runtime->persistent_offset,
1007 context->dma_buffer, module->persistent_size);
1008 sst_dsp_dma_put_channel(dsp);
1010 dev_err(dsp->dev, "error: module copy failed\n");
1014 sst_memcpy32(dsp->addr.lpe + runtime->persistent_offset,
1015 context->buffer, module->persistent_size);
1017 dma_free_coherent(dsp->dma_dev, module->persistent_size,
1018 context->buffer, context->dma_buffer);
1019 context->buffer = NULL;
1022 mutex_unlock(&dsp->mutex);
1025 EXPORT_SYMBOL_GPL(sst_module_runtime_restore);
1027 /* register a DSP memory block for use with FW based modules */
1028 struct sst_mem_block *sst_mem_block_register(struct sst_dsp *dsp, u32 offset,
1029 u32 size, enum sst_mem_type type, const struct sst_block_ops *ops,
1030 u32 index, void *private)
1032 struct sst_mem_block *block;
1034 block = kzalloc(sizeof(*block), GFP_KERNEL);
1038 block->offset = offset;
1040 block->index = index;
1043 block->private = private;
1046 mutex_lock(&dsp->mutex);
1047 list_add(&block->list, &dsp->free_block_list);
1048 mutex_unlock(&dsp->mutex);
1052 EXPORT_SYMBOL_GPL(sst_mem_block_register);
1054 /* unregister all DSP memory blocks */
1055 void sst_mem_block_unregister_all(struct sst_dsp *dsp)
1057 struct sst_mem_block *block, *tmp;
1059 mutex_lock(&dsp->mutex);
1061 /* unregister used blocks */
1062 list_for_each_entry_safe(block, tmp, &dsp->used_block_list, list) {
1063 list_del(&block->list);
1067 /* unregister free blocks */
1068 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
1069 list_del(&block->list);
1073 mutex_unlock(&dsp->mutex);
1075 EXPORT_SYMBOL_GPL(sst_mem_block_unregister_all);
1077 /* allocate scratch buffer blocks */
1078 int sst_block_alloc_scratch(struct sst_dsp *dsp)
1080 struct sst_module *module;
1081 struct sst_block_allocator ba;
1084 mutex_lock(&dsp->mutex);
1086 /* calculate required scratch size */
1087 dsp->scratch_size = 0;
1088 list_for_each_entry(module, &dsp->module_list, list) {
1089 dev_dbg(dsp->dev, "module %d scratch req 0x%x bytes\n",
1090 module->id, module->scratch_size);
1091 if (dsp->scratch_size < module->scratch_size)
1092 dsp->scratch_size = module->scratch_size;
1095 dev_dbg(dsp->dev, "scratch buffer required is 0x%x bytes\n",
1098 if (dsp->scratch_size == 0) {
1099 dev_info(dsp->dev, "no modules need scratch buffer\n");
1100 mutex_unlock(&dsp->mutex);
1104 /* allocate blocks for module scratch buffers */
1105 dev_dbg(dsp->dev, "allocating scratch blocks\n");
1107 ba.size = dsp->scratch_size;
1108 ba.type = SST_MEM_DRAM;
1110 /* do we need to allocate at fixed offset */
1111 if (dsp->scratch_offset != 0) {
1113 dev_dbg(dsp->dev, "block request 0x%x bytes type %d at 0x%x\n",
1114 ba.size, ba.type, ba.offset);
1116 ba.offset = dsp->scratch_offset;
1118 /* alloc blocks that includes this section */
1119 ret = block_alloc_fixed(dsp, &ba, &dsp->scratch_block_list);
1122 dev_dbg(dsp->dev, "block request 0x%x bytes type %d\n",
1126 ret = block_alloc(dsp, &ba, &dsp->scratch_block_list);
1129 dev_err(dsp->dev, "error: can't alloc scratch blocks\n");
1130 mutex_unlock(&dsp->mutex);
1134 ret = block_list_prepare(dsp, &dsp->scratch_block_list);
1136 dev_err(dsp->dev, "error: scratch block prepare failed\n");
1137 mutex_unlock(&dsp->mutex);
1141 /* assign the same offset of scratch to each module */
1142 dsp->scratch_offset = ba.offset;
1143 mutex_unlock(&dsp->mutex);
1144 return dsp->scratch_size;
1146 EXPORT_SYMBOL_GPL(sst_block_alloc_scratch);
1148 /* free all scratch blocks */
1149 void sst_block_free_scratch(struct sst_dsp *dsp)
1151 mutex_lock(&dsp->mutex);
1152 block_list_remove(dsp, &dsp->scratch_block_list);
1153 mutex_unlock(&dsp->mutex);
1155 EXPORT_SYMBOL_GPL(sst_block_free_scratch);
1157 /* get a module from it's unique ID */
1158 struct sst_module *sst_module_get_from_id(struct sst_dsp *dsp, u32 id)
1160 struct sst_module *module;
1162 mutex_lock(&dsp->mutex);
1164 list_for_each_entry(module, &dsp->module_list, list) {
1165 if (module->id == id) {
1166 mutex_unlock(&dsp->mutex);
1171 mutex_unlock(&dsp->mutex);
1174 EXPORT_SYMBOL_GPL(sst_module_get_from_id);
1176 struct sst_module_runtime *sst_module_runtime_get_from_id(
1177 struct sst_module *module, u32 id)
1179 struct sst_module_runtime *runtime;
1180 struct sst_dsp *dsp = module->dsp;
1182 mutex_lock(&dsp->mutex);
1184 list_for_each_entry(runtime, &module->runtime_list, list) {
1185 if (runtime->id == id) {
1186 mutex_unlock(&dsp->mutex);
1191 mutex_unlock(&dsp->mutex);
1194 EXPORT_SYMBOL_GPL(sst_module_runtime_get_from_id);
1196 /* returns block address in DSP address space */
1197 u32 sst_dsp_get_offset(struct sst_dsp *dsp, u32 offset,
1198 enum sst_mem_type type)
1202 return offset - dsp->addr.iram_offset +
1203 dsp->addr.dsp_iram_offset;
1205 return offset - dsp->addr.dram_offset +
1206 dsp->addr.dsp_dram_offset;
1211 EXPORT_SYMBOL_GPL(sst_dsp_get_offset);
1213 struct sst_dsp *sst_dsp_new(struct device *dev,
1214 struct sst_dsp_device *sst_dev, struct sst_pdata *pdata)
1216 struct sst_dsp *sst;
1219 dev_dbg(dev, "initialising audio DSP id 0x%x\n", pdata->id);
1221 sst = devm_kzalloc(dev, sizeof(*sst), GFP_KERNEL);
1225 spin_lock_init(&sst->spinlock);
1226 mutex_init(&sst->mutex);
1228 sst->dma_dev = pdata->dma_dev;
1229 sst->thread_context = sst_dev->thread_context;
1230 sst->sst_dev = sst_dev;
1231 sst->id = pdata->id;
1232 sst->irq = pdata->irq;
1233 sst->ops = sst_dev->ops;
1235 INIT_LIST_HEAD(&sst->used_block_list);
1236 INIT_LIST_HEAD(&sst->free_block_list);
1237 INIT_LIST_HEAD(&sst->module_list);
1238 INIT_LIST_HEAD(&sst->fw_list);
1239 INIT_LIST_HEAD(&sst->scratch_block_list);
1241 /* Initialise SST Audio DSP */
1242 if (sst->ops->init) {
1243 err = sst->ops->init(sst, pdata);
1248 /* Register the ISR */
1249 err = request_threaded_irq(sst->irq, sst->ops->irq_handler,
1250 sst_dev->thread, IRQF_SHARED, "AudioDSP", sst);
1254 err = sst_dma_new(sst);
1256 dev_err(dev, "sst_dma_new failed %d\n", err);
1263 free_irq(sst->irq, sst);
1266 sst->ops->free(sst);
1270 EXPORT_SYMBOL_GPL(sst_dsp_new);
1272 void sst_dsp_free(struct sst_dsp *sst)
1274 free_irq(sst->irq, sst);
1276 sst->ops->free(sst);
1278 sst_dma_free(sst->dma);
1280 EXPORT_SYMBOL_GPL(sst_dsp_free);
1282 MODULE_DESCRIPTION("Intel SST Firmware Loader");
1283 MODULE_LICENSE("GPL v2");