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>
28 #include <asm/pgtable.h>
31 #include "sst-dsp-priv.h"
33 static void sst_memcpy32(volatile void __iomem *dest, void *src, u32 bytes)
37 /* copy one 32 bit word at a time as 64 bit access is not supported */
38 for (i = 0; i < bytes; i += 4)
39 memcpy_toio(dest + i, src + i, 4);
42 /* create new generic firmware object */
43 struct sst_fw *sst_fw_new(struct sst_dsp *dsp,
44 const struct firmware *fw, void *private)
46 struct sst_fw *sst_fw;
49 if (!dsp->ops->parse_fw)
52 sst_fw = kzalloc(sizeof(*sst_fw), GFP_KERNEL);
57 sst_fw->private = private;
58 sst_fw->size = fw->size;
60 err = dma_coerce_mask_and_coherent(dsp->dev, DMA_BIT_MASK(32));
66 /* allocate DMA buffer to store FW data */
67 sst_fw->dma_buf = dma_alloc_coherent(dsp->dev, sst_fw->size,
68 &sst_fw->dmable_fw_paddr, GFP_DMA | GFP_KERNEL);
69 if (!sst_fw->dma_buf) {
70 dev_err(dsp->dev, "error: DMA alloc failed\n");
75 /* copy FW data to DMA-able memory */
76 memcpy((void *)sst_fw->dma_buf, (void *)fw->data, fw->size);
78 /* call core specific FW paser to load FW data into DSP */
79 err = dsp->ops->parse_fw(sst_fw);
81 dev_err(dsp->dev, "error: parse fw failed %d\n", err);
85 mutex_lock(&dsp->mutex);
86 list_add(&sst_fw->list, &dsp->fw_list);
87 mutex_unlock(&dsp->mutex);
92 dma_free_coherent(dsp->dev, sst_fw->size,
94 sst_fw->dmable_fw_paddr);
98 EXPORT_SYMBOL_GPL(sst_fw_new);
100 /* free single firmware object */
101 void sst_fw_free(struct sst_fw *sst_fw)
103 struct sst_dsp *dsp = sst_fw->dsp;
105 mutex_lock(&dsp->mutex);
106 list_del(&sst_fw->list);
107 mutex_unlock(&dsp->mutex);
109 dma_free_coherent(dsp->dev, sst_fw->size, sst_fw->dma_buf,
110 sst_fw->dmable_fw_paddr);
113 EXPORT_SYMBOL_GPL(sst_fw_free);
115 /* free all firmware objects */
116 void sst_fw_free_all(struct sst_dsp *dsp)
118 struct sst_fw *sst_fw, *t;
120 mutex_lock(&dsp->mutex);
121 list_for_each_entry_safe(sst_fw, t, &dsp->fw_list, list) {
123 list_del(&sst_fw->list);
124 dma_free_coherent(dsp->dev, sst_fw->size, sst_fw->dma_buf,
125 sst_fw->dmable_fw_paddr);
128 mutex_unlock(&dsp->mutex);
130 EXPORT_SYMBOL_GPL(sst_fw_free_all);
132 /* create a new SST generic module from FW template */
133 struct sst_module *sst_module_new(struct sst_fw *sst_fw,
134 struct sst_module_template *template, void *private)
136 struct sst_dsp *dsp = sst_fw->dsp;
137 struct sst_module *sst_module;
139 sst_module = kzalloc(sizeof(*sst_module), GFP_KERNEL);
140 if (sst_module == NULL)
143 sst_module->id = template->id;
144 sst_module->dsp = dsp;
145 sst_module->sst_fw = sst_fw;
147 memcpy(&sst_module->s, &template->s, sizeof(struct sst_module_data));
148 memcpy(&sst_module->p, &template->p, sizeof(struct sst_module_data));
150 INIT_LIST_HEAD(&sst_module->block_list);
152 mutex_lock(&dsp->mutex);
153 list_add(&sst_module->list, &dsp->module_list);
154 mutex_unlock(&dsp->mutex);
158 EXPORT_SYMBOL_GPL(sst_module_new);
160 /* free firmware module and remove from available list */
161 void sst_module_free(struct sst_module *sst_module)
163 struct sst_dsp *dsp = sst_module->dsp;
165 mutex_lock(&dsp->mutex);
166 list_del(&sst_module->list);
167 mutex_unlock(&dsp->mutex);
171 EXPORT_SYMBOL_GPL(sst_module_free);
173 static struct sst_mem_block *find_block(struct sst_dsp *dsp, int type,
176 struct sst_mem_block *block;
178 list_for_each_entry(block, &dsp->free_block_list, list) {
179 if (block->type == type && block->offset == offset)
186 static int block_alloc_contiguous(struct sst_module *module,
187 struct sst_module_data *data, u32 offset, int size)
189 struct list_head tmp = LIST_HEAD_INIT(tmp);
190 struct sst_dsp *dsp = module->dsp;
191 struct sst_mem_block *block;
194 block = find_block(dsp, data->type, offset);
196 list_splice(&tmp, &dsp->free_block_list);
200 list_move_tail(&block->list, &tmp);
201 offset += block->size;
205 list_splice(&tmp, &dsp->used_block_list);
209 /* allocate free DSP blocks for module data - callers hold locks */
210 static int block_alloc(struct sst_module *module,
211 struct sst_module_data *data)
213 struct sst_dsp *dsp = module->dsp;
214 struct sst_mem_block *block, *tmp;
220 /* find first free whole blocks that can hold module */
221 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
223 /* ignore blocks with wrong type */
224 if (block->type != data->type)
227 if (data->size > block->size)
230 data->offset = block->offset;
231 block->data_type = data->data_type;
232 block->bytes_used = data->size % block->size;
233 list_add(&block->module_list, &module->block_list);
234 list_move(&block->list, &dsp->used_block_list);
235 dev_dbg(dsp->dev, " *module %d added block %d:%d\n",
236 module->id, block->type, block->index);
240 /* then find free multiple blocks that can hold module */
241 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
243 /* ignore blocks with wrong type */
244 if (block->type != data->type)
247 /* do we span > 1 blocks */
248 if (data->size > block->size) {
249 ret = block_alloc_contiguous(module, data,
250 block->offset + block->size,
251 data->size - block->size);
257 /* not enough free block space */
261 /* remove module from memory - callers hold locks */
262 static void block_module_remove(struct sst_module *module)
264 struct sst_mem_block *block, *tmp;
265 struct sst_dsp *dsp = module->dsp;
268 /* disable each block */
269 list_for_each_entry(block, &module->block_list, module_list) {
271 if (block->ops && block->ops->disable) {
272 err = block->ops->disable(block);
275 "error: cant disable block %d:%d\n",
276 block->type, block->index);
280 /* mark each block as free */
281 list_for_each_entry_safe(block, tmp, &module->block_list, module_list) {
282 list_del(&block->module_list);
283 list_move(&block->list, &dsp->free_block_list);
287 /* prepare the memory block to receive data from host - callers hold locks */
288 static int block_module_prepare(struct sst_module *module)
290 struct sst_mem_block *block;
293 /* enable each block so that's it'e ready for module P/S data */
294 list_for_each_entry(block, &module->block_list, module_list) {
296 if (block->ops && block->ops->enable) {
297 ret = block->ops->enable(block);
299 dev_err(module->dsp->dev,
300 "error: cant disable block %d:%d\n",
301 block->type, block->index);
309 list_for_each_entry(block, &module->block_list, module_list) {
310 if (block->ops && block->ops->disable)
311 block->ops->disable(block);
316 /* allocate memory blocks for static module addresses - callers hold locks */
317 static int block_alloc_fixed(struct sst_module *module,
318 struct sst_module_data *data)
320 struct sst_dsp *dsp = module->dsp;
321 struct sst_mem_block *block, *tmp;
322 u32 end = data->offset + data->size, block_end;
325 /* only IRAM/DRAM blocks are managed */
326 if (data->type != SST_MEM_IRAM && data->type != SST_MEM_DRAM)
329 /* are blocks already attached to this module */
330 list_for_each_entry_safe(block, tmp, &module->block_list, module_list) {
332 /* force compacting mem blocks of the same data_type */
333 if (block->data_type != data->data_type)
336 block_end = block->offset + block->size;
338 /* find block that holds section */
339 if (data->offset >= block->offset && end < block_end)
342 /* does block span more than 1 section */
343 if (data->offset >= block->offset && data->offset < block_end) {
345 err = block_alloc_contiguous(module, data,
346 block->offset + block->size,
347 data->size - block->size + data->offset - block->offset);
351 /* module already owns blocks */
356 /* find first free blocks that can hold section in free list */
357 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
358 block_end = block->offset + block->size;
360 /* find block that holds section */
361 if (data->offset >= block->offset && end < block_end) {
364 block->data_type = data->data_type;
365 list_move(&block->list, &dsp->used_block_list);
366 list_add(&block->module_list, &module->block_list);
370 /* does block span more than 1 section */
371 if (data->offset >= block->offset && data->offset < block_end) {
373 err = block_alloc_contiguous(module, data,
374 block->offset + block->size,
375 data->size - block->size);
380 block->data_type = data->data_type;
381 list_move(&block->list, &dsp->used_block_list);
382 list_add(&block->module_list, &module->block_list);
391 /* Load fixed module data into DSP memory blocks */
392 int sst_module_insert_fixed_block(struct sst_module *module,
393 struct sst_module_data *data)
395 struct sst_dsp *dsp = module->dsp;
398 mutex_lock(&dsp->mutex);
400 /* alloc blocks that includes this section */
401 ret = block_alloc_fixed(module, data);
404 "error: no free blocks for section at offset 0x%x size 0x%x\n",
405 data->offset, data->size);
406 mutex_unlock(&dsp->mutex);
410 /* prepare DSP blocks for module copy */
411 ret = block_module_prepare(module);
413 dev_err(dsp->dev, "error: fw module prepare failed\n");
417 /* copy partial module data to blocks */
418 sst_memcpy32(dsp->addr.lpe + data->offset, data->data, data->size);
420 mutex_unlock(&dsp->mutex);
424 block_module_remove(module);
425 mutex_unlock(&dsp->mutex);
428 EXPORT_SYMBOL_GPL(sst_module_insert_fixed_block);
430 /* Unload entire module from DSP memory */
431 int sst_block_module_remove(struct sst_module *module)
433 struct sst_dsp *dsp = module->dsp;
435 mutex_lock(&dsp->mutex);
436 block_module_remove(module);
437 mutex_unlock(&dsp->mutex);
440 EXPORT_SYMBOL_GPL(sst_block_module_remove);
442 /* register a DSP memory block for use with FW based modules */
443 struct sst_mem_block *sst_mem_block_register(struct sst_dsp *dsp, u32 offset,
444 u32 size, enum sst_mem_type type, struct sst_block_ops *ops, u32 index,
447 struct sst_mem_block *block;
449 block = kzalloc(sizeof(*block), GFP_KERNEL);
453 block->offset = offset;
455 block->index = index;
458 block->private = private;
461 mutex_lock(&dsp->mutex);
462 list_add(&block->list, &dsp->free_block_list);
463 mutex_unlock(&dsp->mutex);
467 EXPORT_SYMBOL_GPL(sst_mem_block_register);
469 /* unregister all DSP memory blocks */
470 void sst_mem_block_unregister_all(struct sst_dsp *dsp)
472 struct sst_mem_block *block, *tmp;
474 mutex_lock(&dsp->mutex);
476 /* unregister used blocks */
477 list_for_each_entry_safe(block, tmp, &dsp->used_block_list, list) {
478 list_del(&block->list);
482 /* unregister free blocks */
483 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) {
484 list_del(&block->list);
488 mutex_unlock(&dsp->mutex);
490 EXPORT_SYMBOL_GPL(sst_mem_block_unregister_all);
492 /* allocate scratch buffer blocks */
493 struct sst_module *sst_mem_block_alloc_scratch(struct sst_dsp *dsp)
495 struct sst_module *sst_module, *scratch;
496 struct sst_mem_block *block, *tmp;
500 scratch = kzalloc(sizeof(struct sst_module), GFP_KERNEL);
504 mutex_lock(&dsp->mutex);
506 /* calculate required scratch size */
507 list_for_each_entry(sst_module, &dsp->module_list, list) {
508 if (scratch->s.size > sst_module->s.size)
509 scratch->s.size = scratch->s.size;
511 scratch->s.size = sst_module->s.size;
514 dev_dbg(dsp->dev, "scratch buffer required is %d bytes\n",
517 /* init scratch module */
519 scratch->s.type = SST_MEM_DRAM;
520 scratch->s.data_type = SST_DATA_S;
521 INIT_LIST_HEAD(&scratch->block_list);
523 /* check free blocks before looking at used blocks for space */
524 if (!list_empty(&dsp->free_block_list))
525 block = list_first_entry(&dsp->free_block_list,
526 struct sst_mem_block, list);
528 block = list_first_entry(&dsp->used_block_list,
529 struct sst_mem_block, list);
530 block_size = block->size;
532 /* allocate blocks for module scratch buffers */
533 dev_dbg(dsp->dev, "allocating scratch blocks\n");
534 ret = block_alloc(scratch, &scratch->s);
536 dev_err(dsp->dev, "error: can't alloc scratch blocks\n");
540 /* assign the same offset of scratch to each module */
541 list_for_each_entry(sst_module, &dsp->module_list, list)
542 sst_module->s.offset = scratch->s.offset;
544 mutex_unlock(&dsp->mutex);
548 list_for_each_entry_safe(block, tmp, &scratch->block_list, module_list)
549 list_del(&block->module_list);
550 mutex_unlock(&dsp->mutex);
553 EXPORT_SYMBOL_GPL(sst_mem_block_alloc_scratch);
555 /* free all scratch blocks */
556 void sst_mem_block_free_scratch(struct sst_dsp *dsp,
557 struct sst_module *scratch)
559 struct sst_mem_block *block, *tmp;
561 mutex_lock(&dsp->mutex);
563 list_for_each_entry_safe(block, tmp, &scratch->block_list, module_list)
564 list_del(&block->module_list);
566 mutex_unlock(&dsp->mutex);
568 EXPORT_SYMBOL_GPL(sst_mem_block_free_scratch);
570 /* get a module from it's unique ID */
571 struct sst_module *sst_module_get_from_id(struct sst_dsp *dsp, u32 id)
573 struct sst_module *module;
575 mutex_lock(&dsp->mutex);
577 list_for_each_entry(module, &dsp->module_list, list) {
578 if (module->id == id) {
579 mutex_unlock(&dsp->mutex);
584 mutex_unlock(&dsp->mutex);
587 EXPORT_SYMBOL_GPL(sst_module_get_from_id);