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/module.h>
23 #include <linux/platform_device.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/dmaengine.h>
26 #include <linux/pci.h>
27 #include <linux/acpi.h>
29 /* supported DMA engine drivers */
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)
57 const u8 *src_byte = src;
62 /* __iowrite32_copy use 32bit size values so divide by 4 */
63 __iowrite32_copy((void *)dest, src, m);
66 for (i = 0; i < n; i++)
67 tmp |= (u32)*(src_byte + m * 4 + i) << (i * 8);
68 __iowrite32_copy((void *)(dest + m * 4), &tmp, 1);
73 static void sst_dma_transfer_complete(void *arg)
75 struct sst_dsp *sst = (struct sst_dsp *)arg;
77 dev_dbg(sst->dev, "DMA: callback\n");
80 static int sst_dsp_dma_copy(struct sst_dsp *sst, dma_addr_t dest_addr,
81 dma_addr_t src_addr, size_t size)
83 struct dma_async_tx_descriptor *desc;
84 struct sst_dma *dma = sst->dma;
86 if (dma->ch == NULL) {
87 dev_err(sst->dev, "error: no DMA channel\n");
91 dev_dbg(sst->dev, "DMA: src: 0x%lx dest 0x%lx size %zu\n",
92 (unsigned long)src_addr, (unsigned long)dest_addr, size);
94 desc = dma->ch->device->device_prep_dma_memcpy(dma->ch, dest_addr,
95 src_addr, size, DMA_CTRL_ACK);
97 dev_err(sst->dev, "error: dma prep memcpy failed\n");
101 desc->callback = sst_dma_transfer_complete;
102 desc->callback_param = sst;
104 desc->tx_submit(desc);
105 dma_wait_for_async_tx(desc);
111 int sst_dsp_dma_copyto(struct sst_dsp *sst, dma_addr_t dest_addr,
112 dma_addr_t src_addr, size_t size)
114 return sst_dsp_dma_copy(sst, dest_addr | SST_HSW_MASK_DMA_ADDR_DSP,
117 EXPORT_SYMBOL_GPL(sst_dsp_dma_copyto);
120 int sst_dsp_dma_copyfrom(struct sst_dsp *sst, dma_addr_t dest_addr,
121 dma_addr_t src_addr, size_t size)
123 return sst_dsp_dma_copy(sst, dest_addr,
124 src_addr | SST_HSW_MASK_DMA_ADDR_DSP, size);
126 EXPORT_SYMBOL_GPL(sst_dsp_dma_copyfrom);
128 /* remove module from memory - callers hold locks */
129 static void block_list_remove(struct sst_dsp *dsp,
130 struct list_head *block_list)
132 struct sst_mem_block *block, *tmp;
135 /* disable each block */
136 list_for_each_entry(block, block_list, module_list) {
138 if (block->ops && block->ops->disable) {
139 err = block->ops->disable(block);
142 "error: cant disable block %d:%d\n",
143 block->type, block->index);
147 /* mark each block as free */
148 list_for_each_entry_safe(block, tmp, block_list, module_list) {
149 list_del(&block->module_list);
150 list_move(&block->list, &dsp->free_block_list);
151 dev_dbg(dsp->dev, "block freed %d:%d at offset 0x%x\n",
152 block->type, block->index, block->offset);
156 /* prepare the memory block to receive data from host - callers hold locks */
157 static int block_list_prepare(struct sst_dsp *dsp,
158 struct list_head *block_list)
160 struct sst_mem_block *block;
163 /* enable each block so that's it'e ready for data */
164 list_for_each_entry(block, block_list, module_list) {
166 if (block->ops && block->ops->enable && !block->users) {
167 ret = block->ops->enable(block);
170 "error: cant disable block %d:%d\n",
171 block->type, block->index);
179 list_for_each_entry(block, block_list, module_list) {
180 if (block->ops && block->ops->disable)
181 block->ops->disable(block);
186 static struct dw_dma_chip *dw_probe(struct device *dev, struct resource *mem,
189 struct dw_dma_chip *chip;
192 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
194 return ERR_PTR(-ENOMEM);
197 chip->regs = devm_ioremap_resource(dev, mem);
198 if (IS_ERR(chip->regs))
199 return ERR_CAST(chip->regs);
201 err = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(31));
207 err = dw_dma_probe(chip);
214 static void dw_remove(struct dw_dma_chip *chip)
219 static bool dma_chan_filter(struct dma_chan *chan, void *param)
221 struct sst_dsp *dsp = (struct sst_dsp *)param;
223 return chan->device->dev == dsp->dma_dev;
226 int sst_dsp_dma_get_channel(struct sst_dsp *dsp, int chan_id)
228 struct sst_dma *dma = dsp->dma;
229 struct dma_slave_config slave;
234 dma_cap_set(DMA_SLAVE, mask);
235 dma_cap_set(DMA_MEMCPY, mask);
237 dma->ch = dma_request_channel(mask, dma_chan_filter, dsp);
238 if (dma->ch == NULL) {
239 dev_err(dsp->dev, "error: DMA request channel failed\n");
243 memset(&slave, 0, sizeof(slave));
244 slave.direction = DMA_MEM_TO_DEV;
245 slave.src_addr_width =
246 slave.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
247 slave.src_maxburst = slave.dst_maxburst = SST_DSP_DMA_MAX_BURST;
249 ret = dmaengine_slave_config(dma->ch, &slave);
251 dev_err(dsp->dev, "error: unable to set DMA slave config %d\n",
253 dma_release_channel(dma->ch);
259 EXPORT_SYMBOL_GPL(sst_dsp_dma_get_channel);
261 void sst_dsp_dma_put_channel(struct sst_dsp *dsp)
263 struct sst_dma *dma = dsp->dma;
268 dma_release_channel(dma->ch);
271 EXPORT_SYMBOL_GPL(sst_dsp_dma_put_channel);
273 static int sst_dma_new(struct sst_dsp *sst)
275 struct sst_pdata *sst_pdata = sst->pdata;
280 if (sst->pdata->resindex_dma_base == -1)
281 /* DMA is not used, return and squelsh error messages */
284 /* configure the correct platform data for whatever DMA engine
285 * is attached to the ADSP IP. */
286 switch (sst->pdata->dma_engine) {
287 case SST_DMA_TYPE_DW:
290 dev_err(sst->dev, "error: invalid DMA engine %d\n",
291 sst->pdata->dma_engine);
295 dma = devm_kzalloc(sst->dev, sizeof(struct sst_dma), GFP_KERNEL);
301 memset(&mem, 0, sizeof(mem));
303 mem.start = sst->addr.lpe_base + sst_pdata->dma_base;
304 mem.end = sst->addr.lpe_base + sst_pdata->dma_base + sst_pdata->dma_size - 1;
305 mem.flags = IORESOURCE_MEM;
307 /* now register DMA engine device */
308 dma->chip = dw_probe(sst->dma_dev, &mem, sst_pdata->irq);
309 if (IS_ERR(dma->chip)) {
310 dev_err(sst->dev, "error: DMA device register failed\n");
311 ret = PTR_ERR(dma->chip);
316 sst->fw_use_dma = true;
320 devm_kfree(sst->dev, dma);
324 static void sst_dma_free(struct sst_dma *dma)
331 dma_release_channel(dma->ch);
334 dw_remove(dma->chip);
338 /* create new generic firmware object */
339 struct sst_fw *sst_fw_new(struct sst_dsp *dsp,
340 const struct firmware *fw, void *private)
342 struct sst_fw *sst_fw;
345 if (!dsp->ops->parse_fw)
348 sst_fw = kzalloc(sizeof(*sst_fw), GFP_KERNEL);
353 sst_fw->private = private;
354 sst_fw->size = fw->size;
356 /* allocate DMA buffer to store FW data */
357 sst_fw->dma_buf = dma_alloc_coherent(dsp->dma_dev, sst_fw->size,
358 &sst_fw->dmable_fw_paddr, GFP_DMA | GFP_KERNEL);
359 if (!sst_fw->dma_buf) {
360 dev_err(dsp->dev, "error: DMA alloc failed\n");
365 /* copy FW data to DMA-able memory */
366 memcpy((void *)sst_fw->dma_buf, (void *)fw->data, fw->size);
368 if (dsp->fw_use_dma) {
369 err = sst_dsp_dma_get_channel(dsp, 0);
374 /* call core specific FW paser to load FW data into DSP */
375 err = dsp->ops->parse_fw(sst_fw);
377 dev_err(dsp->dev, "error: parse fw failed %d\n", err);
382 sst_dsp_dma_put_channel(dsp);
384 mutex_lock(&dsp->mutex);
385 list_add(&sst_fw->list, &dsp->fw_list);
386 mutex_unlock(&dsp->mutex);
392 sst_dsp_dma_put_channel(dsp);
394 dma_free_coherent(dsp->dma_dev, sst_fw->size,
396 sst_fw->dmable_fw_paddr);
397 sst_fw->dma_buf = NULL;
401 EXPORT_SYMBOL_GPL(sst_fw_new);
403 int sst_fw_reload(struct sst_fw *sst_fw)
405 struct sst_dsp *dsp = sst_fw->dsp;
408 dev_dbg(dsp->dev, "reloading firmware\n");
410 /* call core specific FW paser to load FW data into DSP */
411 ret = dsp->ops->parse_fw(sst_fw);
413 dev_err(dsp->dev, "error: parse fw failed %d\n", ret);
417 EXPORT_SYMBOL_GPL(sst_fw_reload);
419 void sst_fw_unload(struct sst_fw *sst_fw)
421 struct sst_dsp *dsp = sst_fw->dsp;
422 struct sst_module *module, *mtmp;
423 struct sst_module_runtime *runtime, *rtmp;
425 dev_dbg(dsp->dev, "unloading firmware\n");
427 mutex_lock(&dsp->mutex);
429 /* check module by module */
430 list_for_each_entry_safe(module, mtmp, &dsp->module_list, list) {
431 if (module->sst_fw == sst_fw) {
433 /* remove runtime modules */
434 list_for_each_entry_safe(runtime, rtmp, &module->runtime_list, list) {
436 block_list_remove(dsp, &runtime->block_list);
437 list_del(&runtime->list);
441 /* now remove the module */
442 block_list_remove(dsp, &module->block_list);
443 list_del(&module->list);
448 /* remove all scratch blocks */
449 block_list_remove(dsp, &dsp->scratch_block_list);
451 mutex_unlock(&dsp->mutex);
453 EXPORT_SYMBOL_GPL(sst_fw_unload);
455 /* free single firmware object */
456 void sst_fw_free(struct sst_fw *sst_fw)
458 struct sst_dsp *dsp = sst_fw->dsp;
460 mutex_lock(&dsp->mutex);
461 list_del(&sst_fw->list);
462 mutex_unlock(&dsp->mutex);
465 dma_free_coherent(dsp->dma_dev, sst_fw->size, sst_fw->dma_buf,
466 sst_fw->dmable_fw_paddr);
469 EXPORT_SYMBOL_GPL(sst_fw_free);
471 /* free all firmware objects */
472 void sst_fw_free_all(struct sst_dsp *dsp)
474 struct sst_fw *sst_fw, *t;
476 mutex_lock(&dsp->mutex);
477 list_for_each_entry_safe(sst_fw, t, &dsp->fw_list, list) {
479 list_del(&sst_fw->list);
480 dma_free_coherent(dsp->dev, sst_fw->size, sst_fw->dma_buf,
481 sst_fw->dmable_fw_paddr);
484 mutex_unlock(&dsp->mutex);
486 EXPORT_SYMBOL_GPL(sst_fw_free_all);
488 /* create a new SST generic module from FW template */
489 struct sst_module *sst_module_new(struct sst_fw *sst_fw,
490 struct sst_module_template *template, void *private)
492 struct sst_dsp *dsp = sst_fw->dsp;
493 struct sst_module *sst_module;
495 sst_module = kzalloc(sizeof(*sst_module), GFP_KERNEL);
496 if (sst_module == NULL)
499 sst_module->id = template->id;
500 sst_module->dsp = dsp;
501 sst_module->sst_fw = sst_fw;
502 sst_module->scratch_size = template->scratch_size;
503 sst_module->persistent_size = template->persistent_size;
504 sst_module->entry = template->entry;
505 sst_module->state = SST_MODULE_STATE_UNLOADED;
507 INIT_LIST_HEAD(&sst_module->block_list);
508 INIT_LIST_HEAD(&sst_module->runtime_list);
510 mutex_lock(&dsp->mutex);
511 list_add(&sst_module->list, &dsp->module_list);
512 mutex_unlock(&dsp->mutex);
516 EXPORT_SYMBOL_GPL(sst_module_new);
518 /* free firmware module and remove from available list */
519 void sst_module_free(struct sst_module *sst_module)
521 struct sst_dsp *dsp = sst_module->dsp;
523 mutex_lock(&dsp->mutex);
524 list_del(&sst_module->list);
525 mutex_unlock(&dsp->mutex);
529 EXPORT_SYMBOL_GPL(sst_module_free);
531 struct sst_module_runtime *sst_module_runtime_new(struct sst_module *module,
532 int id, void *private)
534 struct sst_dsp *dsp = module->dsp;
535 struct sst_module_runtime *runtime;
537 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
543 runtime->module = module;
544 INIT_LIST_HEAD(&runtime->block_list);
546 mutex_lock(&dsp->mutex);
547 list_add(&runtime->list, &module->runtime_list);
548 mutex_unlock(&dsp->mutex);
552 EXPORT_SYMBOL_GPL(sst_module_runtime_new);
554 void sst_module_runtime_free(struct sst_module_runtime *runtime)
556 struct sst_dsp *dsp = runtime->dsp;
558 mutex_lock(&dsp->mutex);
559 list_del(&runtime->list);
560 mutex_unlock(&dsp->mutex);
564 EXPORT_SYMBOL_GPL(sst_module_runtime_free);
566 static struct sst_mem_block *find_block(struct sst_dsp *dsp,
567 struct sst_block_allocator *ba)
569 struct sst_mem_block *block;
571 list_for_each_entry(block, &dsp->free_block_list, list) {
572 if (block->type == ba->type && block->offset == ba->offset)
579 /* Block allocator must be on block boundary */
580 static int block_alloc_contiguous(struct sst_dsp *dsp,
581 struct sst_block_allocator *ba, struct list_head *block_list)
583 struct list_head tmp = LIST_HEAD_INIT(tmp);
584 struct sst_mem_block *block;
585 u32 block_start = SST_HSW_BLOCK_ANY;
586 int size = ba->size, offset = ba->offset;
588 while (ba->size > 0) {
590 block = find_block(dsp, ba);
592 list_splice(&tmp, &dsp->free_block_list);
599 list_move_tail(&block->list, &tmp);
600 ba->offset += block->size;
601 ba->size -= block->size;
606 list_for_each_entry(block, &tmp, list) {
608 if (block->offset < block_start)
609 block_start = block->offset;
611 list_add(&block->module_list, block_list);
613 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
614 block->type, block->index, block->offset);
617 list_splice(&tmp, &dsp->used_block_list);
621 /* allocate first free DSP blocks for data - callers hold locks */
622 static int block_alloc(struct sst_dsp *dsp, struct sst_block_allocator *ba,
623 struct list_head *block_list)
625 struct sst_mem_block *block, *tmp;
631 /* find first free whole blocks that can hold module */
632 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
634 /* ignore blocks with wrong type */
635 if (block->type != ba->type)
638 if (ba->size > block->size)
641 ba->offset = block->offset;
642 block->bytes_used = ba->size % block->size;
643 list_add(&block->module_list, block_list);
644 list_move(&block->list, &dsp->used_block_list);
645 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
646 block->type, block->index, block->offset);
650 /* then find free multiple blocks that can hold module */
651 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
653 /* ignore blocks with wrong type */
654 if (block->type != ba->type)
657 /* do we span > 1 blocks */
658 if (ba->size > block->size) {
660 /* align ba to block boundary */
661 ba->offset = block->offset;
663 ret = block_alloc_contiguous(dsp, ba, block_list);
670 /* not enough free block space */
674 int sst_alloc_blocks(struct sst_dsp *dsp, struct sst_block_allocator *ba,
675 struct list_head *block_list)
679 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n",
680 ba->size, ba->offset, ba->type);
682 mutex_lock(&dsp->mutex);
684 ret = block_alloc(dsp, ba, block_list);
686 dev_err(dsp->dev, "error: can't alloc blocks %d\n", ret);
690 /* prepare DSP blocks for module usage */
691 ret = block_list_prepare(dsp, block_list);
693 dev_err(dsp->dev, "error: prepare failed\n");
696 mutex_unlock(&dsp->mutex);
699 EXPORT_SYMBOL_GPL(sst_alloc_blocks);
701 int sst_free_blocks(struct sst_dsp *dsp, struct list_head *block_list)
703 mutex_lock(&dsp->mutex);
704 block_list_remove(dsp, block_list);
705 mutex_unlock(&dsp->mutex);
708 EXPORT_SYMBOL_GPL(sst_free_blocks);
710 /* allocate memory blocks for static module addresses - callers hold locks */
711 static int block_alloc_fixed(struct sst_dsp *dsp, struct sst_block_allocator *ba,
712 struct list_head *block_list)
714 struct sst_mem_block *block, *tmp;
715 struct sst_block_allocator ba_tmp = *ba;
716 u32 end = ba->offset + ba->size, block_end;
719 /* only IRAM/DRAM blocks are managed */
720 if (ba->type != SST_MEM_IRAM && ba->type != SST_MEM_DRAM)
723 /* are blocks already attached to this module */
724 list_for_each_entry_safe(block, tmp, block_list, module_list) {
726 /* ignore blocks with wrong type */
727 if (block->type != ba->type)
730 block_end = block->offset + block->size;
732 /* find block that holds section */
733 if (ba->offset >= block->offset && end <= block_end)
736 /* does block span more than 1 section */
737 if (ba->offset >= block->offset && ba->offset < block_end) {
739 /* align ba to block boundary */
740 ba_tmp.size -= block_end - ba->offset;
741 ba_tmp.offset = block_end;
742 err = block_alloc_contiguous(dsp, &ba_tmp, block_list);
746 /* module already owns blocks */
751 /* find first free blocks that can hold section in free list */
752 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
753 block_end = block->offset + block->size;
755 /* ignore blocks with wrong type */
756 if (block->type != ba->type)
759 /* find block that holds section */
760 if (ba->offset >= block->offset && end <= block_end) {
763 list_move(&block->list, &dsp->used_block_list);
764 list_add(&block->module_list, block_list);
765 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n",
766 block->type, block->index, block->offset);
770 /* does block span more than 1 section */
771 if (ba->offset >= block->offset && ba->offset < block_end) {
774 list_move(&block->list, &dsp->used_block_list);
775 list_add(&block->module_list, block_list);
776 /* align ba to block boundary */
777 ba_tmp.size -= block_end - ba->offset;
778 ba_tmp.offset = block_end;
780 err = block_alloc_contiguous(dsp, &ba_tmp, block_list);
791 /* Load fixed module data into DSP memory blocks */
792 int sst_module_alloc_blocks(struct sst_module *module)
794 struct sst_dsp *dsp = module->dsp;
795 struct sst_fw *sst_fw = module->sst_fw;
796 struct sst_block_allocator ba;
799 memset(&ba, 0, sizeof(ba));
800 ba.size = module->size;
801 ba.type = module->type;
802 ba.offset = module->offset;
804 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n",
805 ba.size, ba.offset, ba.type);
807 mutex_lock(&dsp->mutex);
809 /* alloc blocks that includes this section */
810 ret = block_alloc_fixed(dsp, &ba, &module->block_list);
813 "error: no free blocks for section at offset 0x%x size 0x%x\n",
814 module->offset, module->size);
815 mutex_unlock(&dsp->mutex);
819 /* prepare DSP blocks for module copy */
820 ret = block_list_prepare(dsp, &module->block_list);
822 dev_err(dsp->dev, "error: fw module prepare failed\n");
826 /* copy partial module data to blocks */
827 if (dsp->fw_use_dma) {
828 ret = sst_dsp_dma_copyto(dsp,
829 dsp->addr.lpe_base + module->offset,
830 sst_fw->dmable_fw_paddr + module->data_offset,
833 dev_err(dsp->dev, "error: module copy failed\n");
837 sst_memcpy32(dsp->addr.lpe + module->offset, module->data,
840 mutex_unlock(&dsp->mutex);
844 block_list_remove(dsp, &module->block_list);
845 mutex_unlock(&dsp->mutex);
848 EXPORT_SYMBOL_GPL(sst_module_alloc_blocks);
850 /* Unload entire module from DSP memory */
851 int sst_module_free_blocks(struct sst_module *module)
853 struct sst_dsp *dsp = module->dsp;
855 mutex_lock(&dsp->mutex);
856 block_list_remove(dsp, &module->block_list);
857 mutex_unlock(&dsp->mutex);
860 EXPORT_SYMBOL_GPL(sst_module_free_blocks);
862 int sst_module_runtime_alloc_blocks(struct sst_module_runtime *runtime,
865 struct sst_dsp *dsp = runtime->dsp;
866 struct sst_module *module = runtime->module;
867 struct sst_block_allocator ba;
870 if (module->persistent_size == 0)
873 memset(&ba, 0, sizeof(ba));
874 ba.size = module->persistent_size;
875 ba.type = SST_MEM_DRAM;
877 mutex_lock(&dsp->mutex);
879 /* do we need to allocate at a fixed address ? */
884 dev_dbg(dsp->dev, "persistent fixed block request 0x%x bytes type %d offset 0x%x\n",
885 ba.size, ba.type, ba.offset);
887 /* alloc blocks that includes this section */
888 ret = block_alloc_fixed(dsp, &ba, &runtime->block_list);
891 dev_dbg(dsp->dev, "persistent block request 0x%x bytes type %d\n",
894 /* alloc blocks that includes this section */
895 ret = block_alloc(dsp, &ba, &runtime->block_list);
899 "error: no free blocks for runtime module size 0x%x\n",
900 module->persistent_size);
901 mutex_unlock(&dsp->mutex);
904 runtime->persistent_offset = ba.offset;
906 /* prepare DSP blocks for module copy */
907 ret = block_list_prepare(dsp, &runtime->block_list);
909 dev_err(dsp->dev, "error: runtime block prepare failed\n");
913 mutex_unlock(&dsp->mutex);
917 block_list_remove(dsp, &module->block_list);
918 mutex_unlock(&dsp->mutex);
921 EXPORT_SYMBOL_GPL(sst_module_runtime_alloc_blocks);
923 int sst_module_runtime_free_blocks(struct sst_module_runtime *runtime)
925 struct sst_dsp *dsp = runtime->dsp;
927 mutex_lock(&dsp->mutex);
928 block_list_remove(dsp, &runtime->block_list);
929 mutex_unlock(&dsp->mutex);
932 EXPORT_SYMBOL_GPL(sst_module_runtime_free_blocks);
934 int sst_module_runtime_save(struct sst_module_runtime *runtime,
935 struct sst_module_runtime_context *context)
937 struct sst_dsp *dsp = runtime->dsp;
938 struct sst_module *module = runtime->module;
941 dev_dbg(dsp->dev, "saving runtime %d memory at 0x%x size 0x%x\n",
942 runtime->id, runtime->persistent_offset,
943 module->persistent_size);
945 context->buffer = dma_alloc_coherent(dsp->dma_dev,
946 module->persistent_size,
947 &context->dma_buffer, GFP_DMA | GFP_KERNEL);
948 if (!context->buffer) {
949 dev_err(dsp->dev, "error: DMA context alloc failed\n");
953 mutex_lock(&dsp->mutex);
955 if (dsp->fw_use_dma) {
957 ret = sst_dsp_dma_get_channel(dsp, 0);
961 ret = sst_dsp_dma_copyfrom(dsp, context->dma_buffer,
962 dsp->addr.lpe_base + runtime->persistent_offset,
963 module->persistent_size);
964 sst_dsp_dma_put_channel(dsp);
966 dev_err(dsp->dev, "error: context copy failed\n");
970 sst_memcpy32(context->buffer, dsp->addr.lpe +
971 runtime->persistent_offset,
972 module->persistent_size);
975 mutex_unlock(&dsp->mutex);
978 EXPORT_SYMBOL_GPL(sst_module_runtime_save);
980 int sst_module_runtime_restore(struct sst_module_runtime *runtime,
981 struct sst_module_runtime_context *context)
983 struct sst_dsp *dsp = runtime->dsp;
984 struct sst_module *module = runtime->module;
987 dev_dbg(dsp->dev, "restoring runtime %d memory at 0x%x size 0x%x\n",
988 runtime->id, runtime->persistent_offset,
989 module->persistent_size);
991 mutex_lock(&dsp->mutex);
993 if (!context->buffer) {
994 dev_info(dsp->dev, "no context buffer need to restore!\n");
998 if (dsp->fw_use_dma) {
1000 ret = sst_dsp_dma_get_channel(dsp, 0);
1004 ret = sst_dsp_dma_copyto(dsp,
1005 dsp->addr.lpe_base + runtime->persistent_offset,
1006 context->dma_buffer, module->persistent_size);
1007 sst_dsp_dma_put_channel(dsp);
1009 dev_err(dsp->dev, "error: module copy failed\n");
1013 sst_memcpy32(dsp->addr.lpe + runtime->persistent_offset,
1014 context->buffer, module->persistent_size);
1016 dma_free_coherent(dsp->dma_dev, module->persistent_size,
1017 context->buffer, context->dma_buffer);
1018 context->buffer = NULL;
1021 mutex_unlock(&dsp->mutex);
1024 EXPORT_SYMBOL_GPL(sst_module_runtime_restore);
1026 /* register a DSP memory block for use with FW based modules */
1027 struct sst_mem_block *sst_mem_block_register(struct sst_dsp *dsp, u32 offset,
1028 u32 size, enum sst_mem_type type, const struct sst_block_ops *ops,
1029 u32 index, void *private)
1031 struct sst_mem_block *block;
1033 block = kzalloc(sizeof(*block), GFP_KERNEL);
1037 block->offset = offset;
1039 block->index = index;
1042 block->private = private;
1045 mutex_lock(&dsp->mutex);
1046 list_add(&block->list, &dsp->free_block_list);
1047 mutex_unlock(&dsp->mutex);
1051 EXPORT_SYMBOL_GPL(sst_mem_block_register);
1053 /* unregister all DSP memory blocks */
1054 void sst_mem_block_unregister_all(struct sst_dsp *dsp)
1056 struct sst_mem_block *block, *tmp;
1058 mutex_lock(&dsp->mutex);
1060 /* unregister used blocks */
1061 list_for_each_entry_safe(block, tmp, &dsp->used_block_list, list) {
1062 list_del(&block->list);
1066 /* unregister free blocks */
1067 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
1068 list_del(&block->list);
1072 mutex_unlock(&dsp->mutex);
1074 EXPORT_SYMBOL_GPL(sst_mem_block_unregister_all);
1076 /* allocate scratch buffer blocks */
1077 int sst_block_alloc_scratch(struct sst_dsp *dsp)
1079 struct sst_module *module;
1080 struct sst_block_allocator ba;
1083 mutex_lock(&dsp->mutex);
1085 /* calculate required scratch size */
1086 dsp->scratch_size = 0;
1087 list_for_each_entry(module, &dsp->module_list, list) {
1088 dev_dbg(dsp->dev, "module %d scratch req 0x%x bytes\n",
1089 module->id, module->scratch_size);
1090 if (dsp->scratch_size < module->scratch_size)
1091 dsp->scratch_size = module->scratch_size;
1094 dev_dbg(dsp->dev, "scratch buffer required is 0x%x bytes\n",
1097 if (dsp->scratch_size == 0) {
1098 dev_info(dsp->dev, "no modules need scratch buffer\n");
1099 mutex_unlock(&dsp->mutex);
1103 /* allocate blocks for module scratch buffers */
1104 dev_dbg(dsp->dev, "allocating scratch blocks\n");
1106 ba.size = dsp->scratch_size;
1107 ba.type = SST_MEM_DRAM;
1109 /* do we need to allocate at fixed offset */
1110 if (dsp->scratch_offset != 0) {
1112 dev_dbg(dsp->dev, "block request 0x%x bytes type %d at 0x%x\n",
1113 ba.size, ba.type, ba.offset);
1115 ba.offset = dsp->scratch_offset;
1117 /* alloc blocks that includes this section */
1118 ret = block_alloc_fixed(dsp, &ba, &dsp->scratch_block_list);
1121 dev_dbg(dsp->dev, "block request 0x%x bytes type %d\n",
1125 ret = block_alloc(dsp, &ba, &dsp->scratch_block_list);
1128 dev_err(dsp->dev, "error: can't alloc scratch blocks\n");
1129 mutex_unlock(&dsp->mutex);
1133 ret = block_list_prepare(dsp, &dsp->scratch_block_list);
1135 dev_err(dsp->dev, "error: scratch block prepare failed\n");
1136 mutex_unlock(&dsp->mutex);
1140 /* assign the same offset of scratch to each module */
1141 dsp->scratch_offset = ba.offset;
1142 mutex_unlock(&dsp->mutex);
1143 return dsp->scratch_size;
1145 EXPORT_SYMBOL_GPL(sst_block_alloc_scratch);
1147 /* free all scratch blocks */
1148 void sst_block_free_scratch(struct sst_dsp *dsp)
1150 mutex_lock(&dsp->mutex);
1151 block_list_remove(dsp, &dsp->scratch_block_list);
1152 mutex_unlock(&dsp->mutex);
1154 EXPORT_SYMBOL_GPL(sst_block_free_scratch);
1156 /* get a module from it's unique ID */
1157 struct sst_module *sst_module_get_from_id(struct sst_dsp *dsp, u32 id)
1159 struct sst_module *module;
1161 mutex_lock(&dsp->mutex);
1163 list_for_each_entry(module, &dsp->module_list, list) {
1164 if (module->id == id) {
1165 mutex_unlock(&dsp->mutex);
1170 mutex_unlock(&dsp->mutex);
1173 EXPORT_SYMBOL_GPL(sst_module_get_from_id);
1175 struct sst_module_runtime *sst_module_runtime_get_from_id(
1176 struct sst_module *module, u32 id)
1178 struct sst_module_runtime *runtime;
1179 struct sst_dsp *dsp = module->dsp;
1181 mutex_lock(&dsp->mutex);
1183 list_for_each_entry(runtime, &module->runtime_list, list) {
1184 if (runtime->id == id) {
1185 mutex_unlock(&dsp->mutex);
1190 mutex_unlock(&dsp->mutex);
1193 EXPORT_SYMBOL_GPL(sst_module_runtime_get_from_id);
1195 /* returns block address in DSP address space */
1196 u32 sst_dsp_get_offset(struct sst_dsp *dsp, u32 offset,
1197 enum sst_mem_type type)
1201 return offset - dsp->addr.iram_offset +
1202 dsp->addr.dsp_iram_offset;
1204 return offset - dsp->addr.dram_offset +
1205 dsp->addr.dsp_dram_offset;
1210 EXPORT_SYMBOL_GPL(sst_dsp_get_offset);
1212 struct sst_dsp *sst_dsp_new(struct device *dev,
1213 struct sst_dsp_device *sst_dev, struct sst_pdata *pdata)
1215 struct sst_dsp *sst;
1218 dev_dbg(dev, "initialising audio DSP id 0x%x\n", pdata->id);
1220 sst = devm_kzalloc(dev, sizeof(*sst), GFP_KERNEL);
1224 spin_lock_init(&sst->spinlock);
1225 mutex_init(&sst->mutex);
1227 sst->dma_dev = pdata->dma_dev;
1228 sst->thread_context = sst_dev->thread_context;
1229 sst->sst_dev = sst_dev;
1230 sst->id = pdata->id;
1231 sst->irq = pdata->irq;
1232 sst->ops = sst_dev->ops;
1234 INIT_LIST_HEAD(&sst->used_block_list);
1235 INIT_LIST_HEAD(&sst->free_block_list);
1236 INIT_LIST_HEAD(&sst->module_list);
1237 INIT_LIST_HEAD(&sst->fw_list);
1238 INIT_LIST_HEAD(&sst->scratch_block_list);
1240 /* Initialise SST Audio DSP */
1241 if (sst->ops->init) {
1242 err = sst->ops->init(sst, pdata);
1247 /* Register the ISR */
1248 err = request_threaded_irq(sst->irq, sst->ops->irq_handler,
1249 sst_dev->thread, IRQF_SHARED, "AudioDSP", sst);
1253 err = sst_dma_new(sst);
1255 dev_err(dev, "sst_dma_new failed %d\n", err);
1262 free_irq(sst->irq, sst);
1265 sst->ops->free(sst);
1269 EXPORT_SYMBOL_GPL(sst_dsp_new);
1271 void sst_dsp_free(struct sst_dsp *sst)
1273 free_irq(sst->irq, sst);
1275 sst->ops->free(sst);
1277 sst_dma_free(sst->dma);
1279 EXPORT_SYMBOL_GPL(sst_dsp_free);
1281 MODULE_DESCRIPTION("Intel SST Firmware Loader");
1282 MODULE_LICENSE("GPL v2");