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/platform_data/dma-dw.h>
30 #include <linux/dma/dw.h>
33 #include <asm/pgtable.h>
36 #include "sst-dsp-priv.h"
38 #define SST_DMA_RESOURCES 2
39 #define SST_DSP_DMA_MAX_BURST 0x3
40 #define SST_HSW_BLOCK_ANY 0xffffffff
42 #define SST_HSW_MASK_DMA_ADDR_DSP 0xfff00000
47 struct dw_dma_chip *chip;
49 struct dma_async_tx_descriptor *desc;
53 static inline void sst_memcpy32(volatile void __iomem *dest, void *src, u32 bytes)
55 /* __iowrite32_copy use 32bit size values so divide by 4 */
56 __iowrite32_copy((void *)dest, src, bytes/4);
59 static void sst_dma_transfer_complete(void *arg)
61 struct sst_dsp *sst = (struct sst_dsp *)arg;
63 dev_dbg(sst->dev, "DMA: callback\n");
66 static int sst_dsp_dma_copy(struct sst_dsp *sst, dma_addr_t dest_addr,
67 dma_addr_t src_addr, size_t size)
69 struct dma_async_tx_descriptor *desc;
70 struct sst_dma *dma = sst->dma;
72 if (dma->ch == NULL) {
73 dev_err(sst->dev, "error: no DMA channel\n");
77 dev_dbg(sst->dev, "DMA: src: 0x%lx dest 0x%lx size %zu\n",
78 (unsigned long)src_addr, (unsigned long)dest_addr, size);
80 desc = dma->ch->device->device_prep_dma_memcpy(dma->ch, dest_addr,
81 src_addr, size, DMA_CTRL_ACK);
83 dev_err(sst->dev, "error: dma prep memcpy failed\n");
87 desc->callback = sst_dma_transfer_complete;
88 desc->callback_param = sst;
90 desc->tx_submit(desc);
91 dma_wait_for_async_tx(desc);
97 int sst_dsp_dma_copyto(struct sst_dsp *sst, dma_addr_t dest_addr,
98 dma_addr_t src_addr, size_t size)
100 return sst_dsp_dma_copy(sst, dest_addr | SST_HSW_MASK_DMA_ADDR_DSP,
103 EXPORT_SYMBOL_GPL(sst_dsp_dma_copyto);
106 int sst_dsp_dma_copyfrom(struct sst_dsp *sst, dma_addr_t dest_addr,
107 dma_addr_t src_addr, size_t size)
109 return sst_dsp_dma_copy(sst, dest_addr,
110 src_addr | SST_HSW_MASK_DMA_ADDR_DSP, size);
112 EXPORT_SYMBOL_GPL(sst_dsp_dma_copyfrom);
114 /* remove module from memory - callers hold locks */
115 static void block_list_remove(struct sst_dsp *dsp,
116 struct list_head *block_list)
118 struct sst_mem_block *block, *tmp;
121 /* disable each block */
122 list_for_each_entry(block, block_list, module_list) {
124 if (block->ops && block->ops->disable) {
125 err = block->ops->disable(block);
128 "error: cant disable block %d:%d\n",
129 block->type, block->index);
133 /* mark each block as free */
134 list_for_each_entry_safe(block, tmp, block_list, module_list) {
135 list_del(&block->module_list);
136 list_move(&block->list, &dsp->free_block_list);
137 dev_dbg(dsp->dev, "block freed %d:%d at offset 0x%x\n",
138 block->type, block->index, block->offset);
142 /* prepare the memory block to receive data from host - callers hold locks */
143 static int block_list_prepare(struct sst_dsp *dsp,
144 struct list_head *block_list)
146 struct sst_mem_block *block;
149 /* enable each block so that's it'e ready for data */
150 list_for_each_entry(block, block_list, module_list) {
152 if (block->ops && block->ops->enable && !block->users) {
153 ret = block->ops->enable(block);
156 "error: cant disable block %d:%d\n",
157 block->type, block->index);
165 list_for_each_entry(block, block_list, module_list) {
166 if (block->ops && block->ops->disable)
167 block->ops->disable(block);
172 static struct dw_dma_platform_data dw_pdata = {
174 .chan_allocation_order = CHAN_ALLOCATION_ASCENDING,
175 .chan_priority = CHAN_PRIORITY_ASCENDING,
178 static struct dw_dma_chip *dw_probe(struct device *dev, struct resource *mem,
181 struct dw_dma_chip *chip;
184 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
186 return ERR_PTR(-ENOMEM);
189 chip->regs = devm_ioremap_resource(dev, mem);
190 if (IS_ERR(chip->regs))
191 return ERR_CAST(chip->regs);
193 err = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(31));
198 err = dw_dma_probe(chip, &dw_pdata);
205 static void dw_remove(struct dw_dma_chip *chip)
210 static bool dma_chan_filter(struct dma_chan *chan, void *param)
212 struct sst_dsp *dsp = (struct sst_dsp *)param;
214 return chan->device->dev == dsp->dma_dev;
217 int sst_dsp_dma_get_channel(struct sst_dsp *dsp, int chan_id)
219 struct sst_dma *dma = dsp->dma;
220 struct dma_slave_config slave;
224 /* The Intel MID DMA engine driver needs the slave config set but
225 * Synopsis DMA engine driver safely ignores the slave config */
227 dma_cap_set(DMA_SLAVE, mask);
228 dma_cap_set(DMA_MEMCPY, mask);
230 dma->ch = dma_request_channel(mask, dma_chan_filter, dsp);
231 if (dma->ch == NULL) {
232 dev_err(dsp->dev, "error: DMA request channel failed\n");
236 memset(&slave, 0, sizeof(slave));
237 slave.direction = DMA_MEM_TO_DEV;
238 slave.src_addr_width =
239 slave.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
240 slave.src_maxburst = slave.dst_maxburst = SST_DSP_DMA_MAX_BURST;
242 ret = dmaengine_slave_config(dma->ch, &slave);
244 dev_err(dsp->dev, "error: unable to set DMA slave config %d\n",
246 dma_release_channel(dma->ch);
252 EXPORT_SYMBOL_GPL(sst_dsp_dma_get_channel);
254 void sst_dsp_dma_put_channel(struct sst_dsp *dsp)
256 struct sst_dma *dma = dsp->dma;
261 dma_release_channel(dma->ch);
264 EXPORT_SYMBOL_GPL(sst_dsp_dma_put_channel);
266 int sst_dma_new(struct sst_dsp *sst)
268 struct sst_pdata *sst_pdata = sst->pdata;
271 const char *dma_dev_name;
274 /* configure the correct platform data for whatever DMA engine
275 * is attached to the ADSP IP. */
276 switch (sst->pdata->dma_engine) {
277 case SST_DMA_TYPE_DW:
278 dma_dev_name = "dw_dmac";
280 case SST_DMA_TYPE_MID:
281 dma_dev_name = "Intel MID DMA";
284 dev_err(sst->dev, "error: invalid DMA engine %d\n",
285 sst->pdata->dma_engine);
289 dma = devm_kzalloc(sst->dev, sizeof(struct sst_dma), GFP_KERNEL);
295 memset(&mem, 0, sizeof(mem));
297 mem.start = sst->addr.lpe_base + sst_pdata->dma_base;
298 mem.end = sst->addr.lpe_base + sst_pdata->dma_base + sst_pdata->dma_size - 1;
299 mem.flags = IORESOURCE_MEM;
301 /* now register DMA engine device */
302 dma->chip = dw_probe(sst->dma_dev, &mem, sst_pdata->irq);
303 if (IS_ERR(dma->chip)) {
304 dev_err(sst->dev, "error: DMA device register failed\n");
305 ret = PTR_ERR(dma->chip);
310 sst->fw_use_dma = true;
314 devm_kfree(sst->dev, dma);
317 EXPORT_SYMBOL(sst_dma_new);
319 void sst_dma_free(struct sst_dma *dma)
326 dma_release_channel(dma->ch);
329 dw_remove(dma->chip);
332 EXPORT_SYMBOL(sst_dma_free);
334 /* create new generic firmware object */
335 struct sst_fw *sst_fw_new(struct sst_dsp *dsp,
336 const struct firmware *fw, void *private)
338 struct sst_fw *sst_fw;
341 if (!dsp->ops->parse_fw)
344 sst_fw = kzalloc(sizeof(*sst_fw), GFP_KERNEL);
349 sst_fw->private = private;
350 sst_fw->size = fw->size;
352 /* allocate DMA buffer to store FW data */
353 sst_fw->dma_buf = dma_alloc_coherent(dsp->dma_dev, sst_fw->size,
354 &sst_fw->dmable_fw_paddr, GFP_DMA | GFP_KERNEL);
355 if (!sst_fw->dma_buf) {
356 dev_err(dsp->dev, "error: DMA alloc failed\n");
361 /* copy FW data to DMA-able memory */
362 memcpy((void *)sst_fw->dma_buf, (void *)fw->data, fw->size);
364 if (dsp->fw_use_dma) {
365 err = sst_dsp_dma_get_channel(dsp, 0);
370 /* call core specific FW paser to load FW data into DSP */
371 err = dsp->ops->parse_fw(sst_fw);
373 dev_err(dsp->dev, "error: parse fw failed %d\n", err);
378 sst_dsp_dma_put_channel(dsp);
380 mutex_lock(&dsp->mutex);
381 list_add(&sst_fw->list, &dsp->fw_list);
382 mutex_unlock(&dsp->mutex);
388 sst_dsp_dma_put_channel(dsp);
390 dma_free_coherent(dsp->dma_dev, sst_fw->size,
392 sst_fw->dmable_fw_paddr);
393 sst_fw->dma_buf = NULL;
397 EXPORT_SYMBOL_GPL(sst_fw_new);
399 int sst_fw_reload(struct sst_fw *sst_fw)
401 struct sst_dsp *dsp = sst_fw->dsp;
404 dev_dbg(dsp->dev, "reloading firmware\n");
406 /* call core specific FW paser to load FW data into DSP */
407 ret = dsp->ops->parse_fw(sst_fw);
409 dev_err(dsp->dev, "error: parse fw failed %d\n", ret);
413 EXPORT_SYMBOL_GPL(sst_fw_reload);
415 void sst_fw_unload(struct sst_fw *sst_fw)
417 struct sst_dsp *dsp = sst_fw->dsp;
418 struct sst_module *module, *mtmp;
419 struct sst_module_runtime *runtime, *rtmp;
421 dev_dbg(dsp->dev, "unloading firmware\n");
423 mutex_lock(&dsp->mutex);
425 /* check module by module */
426 list_for_each_entry_safe(module, mtmp, &dsp->module_list, list) {
427 if (module->sst_fw == sst_fw) {
429 /* remove runtime modules */
430 list_for_each_entry_safe(runtime, rtmp, &module->runtime_list, list) {
432 block_list_remove(dsp, &runtime->block_list);
433 list_del(&runtime->list);
437 /* now remove the module */
438 block_list_remove(dsp, &module->block_list);
439 list_del(&module->list);
444 /* remove all scratch blocks */
445 block_list_remove(dsp, &dsp->scratch_block_list);
447 mutex_unlock(&dsp->mutex);
449 EXPORT_SYMBOL_GPL(sst_fw_unload);
451 /* free single firmware object */
452 void sst_fw_free(struct sst_fw *sst_fw)
454 struct sst_dsp *dsp = sst_fw->dsp;
456 mutex_lock(&dsp->mutex);
457 list_del(&sst_fw->list);
458 mutex_unlock(&dsp->mutex);
461 dma_free_coherent(dsp->dma_dev, sst_fw->size, sst_fw->dma_buf,
462 sst_fw->dmable_fw_paddr);
465 EXPORT_SYMBOL_GPL(sst_fw_free);
467 /* free all firmware objects */
468 void sst_fw_free_all(struct sst_dsp *dsp)
470 struct sst_fw *sst_fw, *t;
472 mutex_lock(&dsp->mutex);
473 list_for_each_entry_safe(sst_fw, t, &dsp->fw_list, list) {
475 list_del(&sst_fw->list);
476 dma_free_coherent(dsp->dev, sst_fw->size, sst_fw->dma_buf,
477 sst_fw->dmable_fw_paddr);
480 mutex_unlock(&dsp->mutex);
482 EXPORT_SYMBOL_GPL(sst_fw_free_all);
484 /* create a new SST generic module from FW template */
485 struct sst_module *sst_module_new(struct sst_fw *sst_fw,
486 struct sst_module_template *template, void *private)
488 struct sst_dsp *dsp = sst_fw->dsp;
489 struct sst_module *sst_module;
491 sst_module = kzalloc(sizeof(*sst_module), GFP_KERNEL);
492 if (sst_module == NULL)
495 sst_module->id = template->id;
496 sst_module->dsp = dsp;
497 sst_module->sst_fw = sst_fw;
498 sst_module->scratch_size = template->scratch_size;
499 sst_module->persistent_size = template->persistent_size;
501 INIT_LIST_HEAD(&sst_module->block_list);
502 INIT_LIST_HEAD(&sst_module->runtime_list);
504 mutex_lock(&dsp->mutex);
505 list_add(&sst_module->list, &dsp->module_list);
506 mutex_unlock(&dsp->mutex);
510 EXPORT_SYMBOL_GPL(sst_module_new);
512 /* free firmware module and remove from available list */
513 void sst_module_free(struct sst_module *sst_module)
515 struct sst_dsp *dsp = sst_module->dsp;
517 mutex_lock(&dsp->mutex);
518 list_del(&sst_module->list);
519 mutex_unlock(&dsp->mutex);
523 EXPORT_SYMBOL_GPL(sst_module_free);
525 struct sst_module_runtime *sst_module_runtime_new(struct sst_module *module,
526 int id, void *private)
528 struct sst_dsp *dsp = module->dsp;
529 struct sst_module_runtime *runtime;
531 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
537 runtime->module = module;
538 INIT_LIST_HEAD(&runtime->block_list);
540 mutex_lock(&dsp->mutex);
541 list_add(&runtime->list, &module->runtime_list);
542 mutex_unlock(&dsp->mutex);
546 EXPORT_SYMBOL_GPL(sst_module_runtime_new);
548 void sst_module_runtime_free(struct sst_module_runtime *runtime)
550 struct sst_dsp *dsp = runtime->dsp;
552 mutex_lock(&dsp->mutex);
553 list_del(&runtime->list);
554 mutex_unlock(&dsp->mutex);
558 EXPORT_SYMBOL_GPL(sst_module_runtime_free);
560 static struct sst_mem_block *find_block(struct sst_dsp *dsp,
561 struct sst_block_allocator *ba)
563 struct sst_mem_block *block;
565 list_for_each_entry(block, &dsp->free_block_list, list) {
566 if (block->type == ba->type && block->offset == ba->offset)
573 /* Block allocator must be on block boundary */
574 static int block_alloc_contiguous(struct sst_dsp *dsp,
575 struct sst_block_allocator *ba, struct list_head *block_list)
577 struct list_head tmp = LIST_HEAD_INIT(tmp);
578 struct sst_mem_block *block;
579 u32 block_start = SST_HSW_BLOCK_ANY;
580 int size = ba->size, offset = ba->offset;
582 while (ba->size > 0) {
584 block = find_block(dsp, ba);
586 list_splice(&tmp, &dsp->free_block_list);
593 list_move_tail(&block->list, &tmp);
594 ba->offset += block->size;
595 ba->size -= block->size;
600 list_for_each_entry(block, &tmp, list) {
602 if (block->offset < block_start)
603 block_start = block->offset;
605 list_add(&block->module_list, block_list);
607 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
608 block->type, block->index, block->offset);
611 list_splice(&tmp, &dsp->used_block_list);
615 /* allocate first free DSP blocks for data - callers hold locks */
616 static int block_alloc(struct sst_dsp *dsp, struct sst_block_allocator *ba,
617 struct list_head *block_list)
619 struct sst_mem_block *block, *tmp;
625 /* find first free whole blocks that can hold module */
626 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
628 /* ignore blocks with wrong type */
629 if (block->type != ba->type)
632 if (ba->size > block->size)
635 ba->offset = block->offset;
636 block->bytes_used = ba->size % block->size;
637 list_add(&block->module_list, block_list);
638 list_move(&block->list, &dsp->used_block_list);
639 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
640 block->type, block->index, block->offset);
644 /* then find free multiple blocks that can hold module */
645 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
647 /* ignore blocks with wrong type */
648 if (block->type != ba->type)
651 /* do we span > 1 blocks */
652 if (ba->size > block->size) {
654 /* align ba to block boundary */
655 ba->offset = block->offset;
657 ret = block_alloc_contiguous(dsp, ba, block_list);
664 /* not enough free block space */
668 int sst_alloc_blocks(struct sst_dsp *dsp, struct sst_block_allocator *ba,
669 struct list_head *block_list)
673 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n",
674 ba->size, ba->offset, ba->type);
676 mutex_lock(&dsp->mutex);
678 ret = block_alloc(dsp, ba, block_list);
680 dev_err(dsp->dev, "error: can't alloc blocks %d\n", ret);
684 /* prepare DSP blocks for module usage */
685 ret = block_list_prepare(dsp, block_list);
687 dev_err(dsp->dev, "error: prepare failed\n");
690 mutex_unlock(&dsp->mutex);
693 EXPORT_SYMBOL_GPL(sst_alloc_blocks);
695 int sst_free_blocks(struct sst_dsp *dsp, struct list_head *block_list)
697 mutex_lock(&dsp->mutex);
698 block_list_remove(dsp, block_list);
699 mutex_unlock(&dsp->mutex);
702 EXPORT_SYMBOL_GPL(sst_free_blocks);
704 /* allocate memory blocks for static module addresses - callers hold locks */
705 static int block_alloc_fixed(struct sst_dsp *dsp, struct sst_block_allocator *ba,
706 struct list_head *block_list)
708 struct sst_mem_block *block, *tmp;
709 struct sst_block_allocator ba_tmp = *ba;
710 u32 end = ba->offset + ba->size, block_end;
713 /* only IRAM/DRAM blocks are managed */
714 if (ba->type != SST_MEM_IRAM && ba->type != SST_MEM_DRAM)
717 /* are blocks already attached to this module */
718 list_for_each_entry_safe(block, tmp, block_list, module_list) {
720 /* ignore blocks with wrong type */
721 if (block->type != ba->type)
724 block_end = block->offset + block->size;
726 /* find block that holds section */
727 if (ba->offset >= block->offset && end <= block_end)
730 /* does block span more than 1 section */
731 if (ba->offset >= block->offset && ba->offset < block_end) {
733 /* align ba to block boundary */
734 ba_tmp.size -= block_end - ba->offset;
735 ba_tmp.offset = block_end;
736 err = block_alloc_contiguous(dsp, &ba_tmp, block_list);
740 /* module already owns blocks */
745 /* find first free blocks that can hold section in free list */
746 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
747 block_end = block->offset + block->size;
749 /* ignore blocks with wrong type */
750 if (block->type != ba->type)
753 /* find block that holds section */
754 if (ba->offset >= block->offset && end <= block_end) {
757 list_move(&block->list, &dsp->used_block_list);
758 list_add(&block->module_list, block_list);
759 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
760 block->type, block->index, block->offset);
764 /* does block span more than 1 section */
765 if (ba->offset >= block->offset && ba->offset < block_end) {
768 list_move(&block->list, &dsp->used_block_list);
769 list_add(&block->module_list, block_list);
770 /* align ba to block boundary */
771 ba_tmp.size -= block_end - ba->offset;
772 ba_tmp.offset = block_end;
774 err = block_alloc_contiguous(dsp, &ba_tmp, block_list);
785 /* Load fixed module data into DSP memory blocks */
786 int sst_module_alloc_blocks(struct sst_module *module)
788 struct sst_dsp *dsp = module->dsp;
789 struct sst_fw *sst_fw = module->sst_fw;
790 struct sst_block_allocator ba;
793 ba.size = module->size;
794 ba.type = module->type;
795 ba.offset = module->offset;
797 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n",
798 ba.size, ba.offset, ba.type);
800 mutex_lock(&dsp->mutex);
802 /* alloc blocks that includes this section */
803 ret = block_alloc_fixed(dsp, &ba, &module->block_list);
806 "error: no free blocks for section at offset 0x%x size 0x%x\n",
807 module->offset, module->size);
808 mutex_unlock(&dsp->mutex);
812 /* prepare DSP blocks for module copy */
813 ret = block_list_prepare(dsp, &module->block_list);
815 dev_err(dsp->dev, "error: fw module prepare failed\n");
819 /* copy partial module data to blocks */
820 if (dsp->fw_use_dma) {
821 ret = sst_dsp_dma_copyto(dsp,
822 dsp->addr.lpe_base + module->offset,
823 sst_fw->dmable_fw_paddr + module->data_offset,
826 dev_err(dsp->dev, "error: module copy failed\n");
830 sst_memcpy32(dsp->addr.lpe + module->offset, module->data,
833 mutex_unlock(&dsp->mutex);
837 block_list_remove(dsp, &module->block_list);
838 mutex_unlock(&dsp->mutex);
841 EXPORT_SYMBOL_GPL(sst_module_alloc_blocks);
843 /* Unload entire module from DSP memory */
844 int sst_module_free_blocks(struct sst_module *module)
846 struct sst_dsp *dsp = module->dsp;
848 mutex_lock(&dsp->mutex);
849 block_list_remove(dsp, &module->block_list);
850 mutex_unlock(&dsp->mutex);
853 EXPORT_SYMBOL_GPL(sst_module_free_blocks);
855 int sst_module_runtime_alloc_blocks(struct sst_module_runtime *runtime,
858 struct sst_dsp *dsp = runtime->dsp;
859 struct sst_module *module = runtime->module;
860 struct sst_block_allocator ba;
863 if (module->persistent_size == 0)
866 ba.size = module->persistent_size;
867 ba.type = SST_MEM_DRAM;
869 mutex_lock(&dsp->mutex);
871 /* do we need to allocate at a fixed address ? */
876 dev_dbg(dsp->dev, "persistent fixed block request 0x%x bytes type %d offset 0x%x\n",
877 ba.size, ba.type, ba.offset);
879 /* alloc blocks that includes this section */
880 ret = block_alloc_fixed(dsp, &ba, &runtime->block_list);
883 dev_dbg(dsp->dev, "persistent block request 0x%x bytes type %d\n",
886 /* alloc blocks that includes this section */
887 ret = block_alloc(dsp, &ba, &runtime->block_list);
891 "error: no free blocks for runtime module size 0x%x\n",
892 module->persistent_size);
893 mutex_unlock(&dsp->mutex);
896 runtime->persistent_offset = ba.offset;
898 /* prepare DSP blocks for module copy */
899 ret = block_list_prepare(dsp, &runtime->block_list);
901 dev_err(dsp->dev, "error: runtime block prepare failed\n");
905 mutex_unlock(&dsp->mutex);
909 block_list_remove(dsp, &module->block_list);
910 mutex_unlock(&dsp->mutex);
913 EXPORT_SYMBOL_GPL(sst_module_runtime_alloc_blocks);
915 int sst_module_runtime_free_blocks(struct sst_module_runtime *runtime)
917 struct sst_dsp *dsp = runtime->dsp;
919 mutex_lock(&dsp->mutex);
920 block_list_remove(dsp, &runtime->block_list);
921 mutex_unlock(&dsp->mutex);
924 EXPORT_SYMBOL_GPL(sst_module_runtime_free_blocks);
926 int sst_module_runtime_save(struct sst_module_runtime *runtime,
927 struct sst_module_runtime_context *context)
929 struct sst_dsp *dsp = runtime->dsp;
930 struct sst_module *module = runtime->module;
933 dev_dbg(dsp->dev, "saving runtime %d memory at 0x%x size 0x%x\n",
934 runtime->id, runtime->persistent_offset,
935 module->persistent_size);
937 context->buffer = dma_alloc_coherent(dsp->dma_dev,
938 module->persistent_size,
939 &context->dma_buffer, GFP_DMA | GFP_KERNEL);
940 if (!context->buffer) {
941 dev_err(dsp->dev, "error: DMA context alloc failed\n");
945 mutex_lock(&dsp->mutex);
947 if (dsp->fw_use_dma) {
949 ret = sst_dsp_dma_get_channel(dsp, 0);
953 ret = sst_dsp_dma_copyfrom(dsp, context->dma_buffer,
954 dsp->addr.lpe_base + runtime->persistent_offset,
955 module->persistent_size);
956 sst_dsp_dma_put_channel(dsp);
958 dev_err(dsp->dev, "error: context copy failed\n");
962 sst_memcpy32(context->buffer, dsp->addr.lpe +
963 runtime->persistent_offset,
964 module->persistent_size);
967 mutex_unlock(&dsp->mutex);
970 EXPORT_SYMBOL_GPL(sst_module_runtime_save);
972 int sst_module_runtime_restore(struct sst_module_runtime *runtime,
973 struct sst_module_runtime_context *context)
975 struct sst_dsp *dsp = runtime->dsp;
976 struct sst_module *module = runtime->module;
979 dev_dbg(dsp->dev, "restoring runtime %d memory at 0x%x size 0x%x\n",
980 runtime->id, runtime->persistent_offset,
981 module->persistent_size);
983 mutex_lock(&dsp->mutex);
985 if (!context->buffer) {
986 dev_info(dsp->dev, "no context buffer need to restore!\n");
990 if (dsp->fw_use_dma) {
992 ret = sst_dsp_dma_get_channel(dsp, 0);
996 ret = sst_dsp_dma_copyto(dsp,
997 dsp->addr.lpe_base + runtime->persistent_offset,
998 context->dma_buffer, module->persistent_size);
999 sst_dsp_dma_put_channel(dsp);
1001 dev_err(dsp->dev, "error: module copy failed\n");
1005 sst_memcpy32(dsp->addr.lpe + runtime->persistent_offset,
1006 context->buffer, module->persistent_size);
1008 dma_free_coherent(dsp->dma_dev, module->persistent_size,
1009 context->buffer, context->dma_buffer);
1010 context->buffer = NULL;
1013 mutex_unlock(&dsp->mutex);
1016 EXPORT_SYMBOL_GPL(sst_module_runtime_restore);
1018 /* register a DSP memory block for use with FW based modules */
1019 struct sst_mem_block *sst_mem_block_register(struct sst_dsp *dsp, u32 offset,
1020 u32 size, enum sst_mem_type type, struct sst_block_ops *ops, u32 index,
1023 struct sst_mem_block *block;
1025 block = kzalloc(sizeof(*block), GFP_KERNEL);
1029 block->offset = offset;
1031 block->index = index;
1034 block->private = private;
1037 mutex_lock(&dsp->mutex);
1038 list_add(&block->list, &dsp->free_block_list);
1039 mutex_unlock(&dsp->mutex);
1043 EXPORT_SYMBOL_GPL(sst_mem_block_register);
1045 /* unregister all DSP memory blocks */
1046 void sst_mem_block_unregister_all(struct sst_dsp *dsp)
1048 struct sst_mem_block *block, *tmp;
1050 mutex_lock(&dsp->mutex);
1052 /* unregister used blocks */
1053 list_for_each_entry_safe(block, tmp, &dsp->used_block_list, list) {
1054 list_del(&block->list);
1058 /* unregister free blocks */
1059 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
1060 list_del(&block->list);
1064 mutex_unlock(&dsp->mutex);
1066 EXPORT_SYMBOL_GPL(sst_mem_block_unregister_all);
1068 /* allocate scratch buffer blocks */
1069 int sst_block_alloc_scratch(struct sst_dsp *dsp)
1071 struct sst_module *module;
1072 struct sst_block_allocator ba;
1075 mutex_lock(&dsp->mutex);
1077 /* calculate required scratch size */
1078 dsp->scratch_size = 0;
1079 list_for_each_entry(module, &dsp->module_list, list) {
1080 dev_dbg(dsp->dev, "module %d scratch req 0x%x bytes\n",
1081 module->id, module->scratch_size);
1082 if (dsp->scratch_size < module->scratch_size)
1083 dsp->scratch_size = module->scratch_size;
1086 dev_dbg(dsp->dev, "scratch buffer required is 0x%x bytes\n",
1089 if (dsp->scratch_size == 0) {
1090 dev_info(dsp->dev, "no modules need scratch buffer\n");
1091 mutex_unlock(&dsp->mutex);
1095 /* allocate blocks for module scratch buffers */
1096 dev_dbg(dsp->dev, "allocating scratch blocks\n");
1098 ba.size = dsp->scratch_size;
1099 ba.type = SST_MEM_DRAM;
1101 /* do we need to allocate at fixed offset */
1102 if (dsp->scratch_offset != 0) {
1104 dev_dbg(dsp->dev, "block request 0x%x bytes type %d at 0x%x\n",
1105 ba.size, ba.type, ba.offset);
1107 ba.offset = dsp->scratch_offset;
1109 /* alloc blocks that includes this section */
1110 ret = block_alloc_fixed(dsp, &ba, &dsp->scratch_block_list);
1113 dev_dbg(dsp->dev, "block request 0x%x bytes type %d\n",
1117 ret = block_alloc(dsp, &ba, &dsp->scratch_block_list);
1120 dev_err(dsp->dev, "error: can't alloc scratch blocks\n");
1121 mutex_unlock(&dsp->mutex);
1125 ret = block_list_prepare(dsp, &dsp->scratch_block_list);
1127 dev_err(dsp->dev, "error: scratch block prepare failed\n");
1128 mutex_unlock(&dsp->mutex);
1132 /* assign the same offset of scratch to each module */
1133 dsp->scratch_offset = ba.offset;
1134 mutex_unlock(&dsp->mutex);
1135 return dsp->scratch_size;
1137 EXPORT_SYMBOL_GPL(sst_block_alloc_scratch);
1139 /* free all scratch blocks */
1140 void sst_block_free_scratch(struct sst_dsp *dsp)
1142 mutex_lock(&dsp->mutex);
1143 block_list_remove(dsp, &dsp->scratch_block_list);
1144 mutex_unlock(&dsp->mutex);
1146 EXPORT_SYMBOL_GPL(sst_block_free_scratch);
1148 /* get a module from it's unique ID */
1149 struct sst_module *sst_module_get_from_id(struct sst_dsp *dsp, u32 id)
1151 struct sst_module *module;
1153 mutex_lock(&dsp->mutex);
1155 list_for_each_entry(module, &dsp->module_list, list) {
1156 if (module->id == id) {
1157 mutex_unlock(&dsp->mutex);
1162 mutex_unlock(&dsp->mutex);
1165 EXPORT_SYMBOL_GPL(sst_module_get_from_id);
1167 struct sst_module_runtime *sst_module_runtime_get_from_id(
1168 struct sst_module *module, u32 id)
1170 struct sst_module_runtime *runtime;
1171 struct sst_dsp *dsp = module->dsp;
1173 mutex_lock(&dsp->mutex);
1175 list_for_each_entry(runtime, &module->runtime_list, list) {
1176 if (runtime->id == id) {
1177 mutex_unlock(&dsp->mutex);
1182 mutex_unlock(&dsp->mutex);
1185 EXPORT_SYMBOL_GPL(sst_module_runtime_get_from_id);
1187 /* returns block address in DSP address space */
1188 u32 sst_dsp_get_offset(struct sst_dsp *dsp, u32 offset,
1189 enum sst_mem_type type)
1193 return offset - dsp->addr.iram_offset +
1194 dsp->addr.dsp_iram_offset;
1196 return offset - dsp->addr.dram_offset +
1197 dsp->addr.dsp_dram_offset;
1202 EXPORT_SYMBOL_GPL(sst_dsp_get_offset);