1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  sst_dsp.c - Intel SST Driver for audio engine
4  *
5  *  Copyright (C) 2008-14	Intel Corp
6  *  Authors:	Vinod Koul <vinod.koul@intel.com>
7  *		Harsha Priya <priya.harsha@intel.com>
8  *		Dharageswari R <dharageswari.r@intel.com>
9  *		KP Jeeja <jeeja.kp@intel.com>
10  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  *
12  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
13  *
14  *  This file contains all dsp controlling functions like firmware download,
15  * setting/resetting dsp cores, etc
16  */
17 #include <linux/pci.h>
18 #include <linux/delay.h>
19 #include <linux/fs.h>
20 #include <linux/sched.h>
21 #include <linux/firmware.h>
22 #include <linux/dmaengine.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/pm_qos.h>
25 #include <sound/core.h>
26 #include <sound/pcm.h>
27 #include <sound/soc.h>
28 #include <sound/compress_driver.h>
29 #include <asm/platform_sst_audio.h>
30 #include "../sst-mfld-platform.h"
31 #include "sst.h"
32 
memcpy32_toio(void __iomem * dst,const void * src,int count)33 void memcpy32_toio(void __iomem *dst, const void *src, int count)
34 {
35 	/* __iowrite32_copy uses 32-bit count values so divide by 4 for
36 	 * right count in words
37 	 */
38 	__iowrite32_copy(dst, src, count / 4);
39 }
40 
memcpy32_fromio(void * dst,const void __iomem * src,int count)41 void memcpy32_fromio(void *dst, const void __iomem *src, int count)
42 {
43 	/* __ioread32_copy uses 32-bit count values so divide by 4 for
44 	 * right count in words
45 	 */
46 	__ioread32_copy(dst, src, count / 4);
47 }
48 
49 /**
50  * intel_sst_reset_dsp_mrfld - Resetting SST DSP
51  * @sst_drv_ctx: intel_sst_drv context pointer
52  *
53  * This resets DSP in case of MRFLD platfroms
54  */
intel_sst_reset_dsp_mrfld(struct intel_sst_drv * sst_drv_ctx)55 int intel_sst_reset_dsp_mrfld(struct intel_sst_drv *sst_drv_ctx)
56 {
57 	union config_status_reg_mrfld csr;
58 
59 	dev_dbg(sst_drv_ctx->dev, "sst: Resetting the DSP in mrfld\n");
60 	csr.full = sst_shim_read64(sst_drv_ctx->shim, SST_CSR);
61 
62 	dev_dbg(sst_drv_ctx->dev, "value:0x%llx\n", csr.full);
63 
64 	csr.full |= 0x7;
65 	sst_shim_write64(sst_drv_ctx->shim, SST_CSR, csr.full);
66 	csr.full = sst_shim_read64(sst_drv_ctx->shim, SST_CSR);
67 
68 	dev_dbg(sst_drv_ctx->dev, "value:0x%llx\n", csr.full);
69 
70 	csr.full &= ~(0x1);
71 	sst_shim_write64(sst_drv_ctx->shim, SST_CSR, csr.full);
72 
73 	csr.full = sst_shim_read64(sst_drv_ctx->shim, SST_CSR);
74 	dev_dbg(sst_drv_ctx->dev, "value:0x%llx\n", csr.full);
75 	return 0;
76 }
77 
78 /**
79  * sst_start_mrfld - Start the SST DSP processor
80  * @sst_drv_ctx: intel_sst_drv context pointer
81  *
82  * This starts the DSP in MERRIFIELD platfroms
83  */
sst_start_mrfld(struct intel_sst_drv * sst_drv_ctx)84 int sst_start_mrfld(struct intel_sst_drv *sst_drv_ctx)
85 {
86 	union config_status_reg_mrfld csr;
87 
88 	dev_dbg(sst_drv_ctx->dev, "sst: Starting the DSP in mrfld LALALALA\n");
89 	csr.full = sst_shim_read64(sst_drv_ctx->shim, SST_CSR);
90 	dev_dbg(sst_drv_ctx->dev, "value:0x%llx\n", csr.full);
91 
92 	csr.full |= 0x7;
93 	sst_shim_write64(sst_drv_ctx->shim, SST_CSR, csr.full);
94 
95 	csr.full = sst_shim_read64(sst_drv_ctx->shim, SST_CSR);
96 	dev_dbg(sst_drv_ctx->dev, "value:0x%llx\n", csr.full);
97 
98 	csr.part.xt_snoop = 1;
99 	csr.full &= ~(0x5);
100 	sst_shim_write64(sst_drv_ctx->shim, SST_CSR, csr.full);
101 
102 	csr.full = sst_shim_read64(sst_drv_ctx->shim, SST_CSR);
103 	dev_dbg(sst_drv_ctx->dev, "sst: Starting the DSP_merrifield:%llx\n",
104 			csr.full);
105 	return 0;
106 }
107 
sst_validate_fw_image(struct intel_sst_drv * ctx,unsigned long size,struct fw_module_header ** module,u32 * num_modules)108 static int sst_validate_fw_image(struct intel_sst_drv *ctx, unsigned long size,
109 		struct fw_module_header **module, u32 *num_modules)
110 {
111 	struct sst_fw_header *header;
112 	const void *sst_fw_in_mem = ctx->fw_in_mem;
113 
114 	dev_dbg(ctx->dev, "Enter\n");
115 
116 	/* Read the header information from the data pointer */
117 	header = (struct sst_fw_header *)sst_fw_in_mem;
118 	dev_dbg(ctx->dev,
119 		"header sign=%s size=%x modules=%x fmt=%x size=%zx\n",
120 		header->signature, header->file_size, header->modules,
121 		header->file_format, sizeof(*header));
122 
123 	/* verify FW */
124 	if ((strncmp(header->signature, SST_FW_SIGN, 4) != 0) ||
125 		(size != header->file_size + sizeof(*header))) {
126 		/* Invalid FW signature */
127 		dev_err(ctx->dev, "InvalidFW sign/filesize mismatch\n");
128 		return -EINVAL;
129 	}
130 	*num_modules = header->modules;
131 	*module = (void *)sst_fw_in_mem + sizeof(*header);
132 
133 	return 0;
134 }
135 
136 /*
137  * sst_fill_memcpy_list - Fill the memcpy list
138  *
139  * @memcpy_list: List to be filled
140  * @destn: Destination addr to be filled in the list
141  * @src: Source addr to be filled in the list
142  * @size: Size to be filled in the list
143  *
144  * Adds the node to the list after required fields
145  * are populated in the node
146  */
sst_fill_memcpy_list(struct list_head * memcpy_list,void * destn,const void * src,u32 size,bool is_io)147 static int sst_fill_memcpy_list(struct list_head *memcpy_list,
148 			void *destn, const void *src, u32 size, bool is_io)
149 {
150 	struct sst_memcpy_list *listnode;
151 
152 	listnode = kzalloc(sizeof(*listnode), GFP_KERNEL);
153 	if (listnode == NULL)
154 		return -ENOMEM;
155 	listnode->dstn = destn;
156 	listnode->src = src;
157 	listnode->size = size;
158 	listnode->is_io = is_io;
159 	list_add_tail(&listnode->memcpylist, memcpy_list);
160 
161 	return 0;
162 }
163 
164 /**
165  * sst_parse_module_memcpy - Parse audio FW modules and populate the memcpy list
166  *
167  * @sst_drv_ctx		: driver context
168  * @module		: FW module header
169  * @memcpy_list	: Pointer to the list to be populated
170  * Create the memcpy list as the number of block to be copied
171  * returns error or 0 if module sizes are proper
172  */
sst_parse_module_memcpy(struct intel_sst_drv * sst_drv_ctx,struct fw_module_header * module,struct list_head * memcpy_list)173 static int sst_parse_module_memcpy(struct intel_sst_drv *sst_drv_ctx,
174 		struct fw_module_header *module, struct list_head *memcpy_list)
175 {
176 	struct fw_block_info *block;
177 	u32 count;
178 	int ret_val = 0;
179 	void __iomem *ram_iomem;
180 
181 	dev_dbg(sst_drv_ctx->dev, "module sign %s size %x blocks %x type %x\n",
182 			module->signature, module->mod_size,
183 			module->blocks, module->type);
184 	dev_dbg(sst_drv_ctx->dev, "module entrypoint 0x%x\n", module->entry_point);
185 
186 	block = (void *)module + sizeof(*module);
187 
188 	for (count = 0; count < module->blocks; count++) {
189 		if (block->size <= 0) {
190 			dev_err(sst_drv_ctx->dev, "block size invalid\n");
191 			return -EINVAL;
192 		}
193 		switch (block->type) {
194 		case SST_IRAM:
195 			ram_iomem = sst_drv_ctx->iram;
196 			break;
197 		case SST_DRAM:
198 			ram_iomem = sst_drv_ctx->dram;
199 			break;
200 		case SST_DDR:
201 			ram_iomem = sst_drv_ctx->ddr;
202 			break;
203 		case SST_CUSTOM_INFO:
204 			block = (void *)block + sizeof(*block) + block->size;
205 			continue;
206 		default:
207 			dev_err(sst_drv_ctx->dev, "wrong ram type0x%x in block0x%x\n",
208 					block->type, count);
209 			return -EINVAL;
210 		}
211 
212 		ret_val = sst_fill_memcpy_list(memcpy_list,
213 				ram_iomem + block->ram_offset,
214 				(void *)block + sizeof(*block), block->size, 1);
215 		if (ret_val)
216 			return ret_val;
217 
218 		block = (void *)block + sizeof(*block) + block->size;
219 	}
220 	return 0;
221 }
222 
223 /**
224  * sst_parse_fw_memcpy - parse the firmware image & populate the list for memcpy
225  *
226  * @ctx			: pointer to drv context
227  * @size		: size of the firmware
228  * @fw_list		: pointer to list_head to be populated
229  * This function parses the FW image and saves the parsed image in the list
230  * for memcpy
231  */
sst_parse_fw_memcpy(struct intel_sst_drv * ctx,unsigned long size,struct list_head * fw_list)232 static int sst_parse_fw_memcpy(struct intel_sst_drv *ctx, unsigned long size,
233 				struct list_head *fw_list)
234 {
235 	struct fw_module_header *module;
236 	u32 count, num_modules;
237 	int ret_val;
238 
239 	ret_val = sst_validate_fw_image(ctx, size, &module, &num_modules);
240 	if (ret_val)
241 		return ret_val;
242 
243 	for (count = 0; count < num_modules; count++) {
244 		ret_val = sst_parse_module_memcpy(ctx, module, fw_list);
245 		if (ret_val)
246 			return ret_val;
247 		module = (void *)module + sizeof(*module) + module->mod_size;
248 	}
249 
250 	return 0;
251 }
252 
253 /**
254  * sst_do_memcpy - function initiates the memcpy
255  *
256  * @memcpy_list: Pter to memcpy list on which the memcpy needs to be initiated
257  *
258  * Triggers the memcpy
259  */
sst_do_memcpy(struct list_head * memcpy_list)260 static void sst_do_memcpy(struct list_head *memcpy_list)
261 {
262 	struct sst_memcpy_list *listnode;
263 
264 	list_for_each_entry(listnode, memcpy_list, memcpylist) {
265 		if (listnode->is_io)
266 			memcpy32_toio((void __iomem *)listnode->dstn,
267 					listnode->src, listnode->size);
268 		else
269 			memcpy(listnode->dstn, listnode->src, listnode->size);
270 	}
271 }
272 
sst_memcpy_free_resources(struct intel_sst_drv * sst_drv_ctx)273 void sst_memcpy_free_resources(struct intel_sst_drv *sst_drv_ctx)
274 {
275 	struct sst_memcpy_list *listnode, *tmplistnode;
276 
277 	/* Free the list */
278 	list_for_each_entry_safe(listnode, tmplistnode,
279 				 &sst_drv_ctx->memcpy_list, memcpylist) {
280 		list_del(&listnode->memcpylist);
281 		kfree(listnode);
282 	}
283 }
284 
sst_cache_and_parse_fw(struct intel_sst_drv * sst,const struct firmware * fw)285 static int sst_cache_and_parse_fw(struct intel_sst_drv *sst,
286 		const struct firmware *fw)
287 {
288 	int retval = 0;
289 
290 	sst->fw_in_mem = kzalloc(fw->size, GFP_KERNEL);
291 	if (!sst->fw_in_mem) {
292 		retval = -ENOMEM;
293 		goto end_release;
294 	}
295 	dev_dbg(sst->dev, "copied fw to %p", sst->fw_in_mem);
296 	dev_dbg(sst->dev, "phys: %lx", (unsigned long)virt_to_phys(sst->fw_in_mem));
297 	memcpy(sst->fw_in_mem, fw->data, fw->size);
298 	retval = sst_parse_fw_memcpy(sst, fw->size, &sst->memcpy_list);
299 	if (retval) {
300 		dev_err(sst->dev, "Failed to parse fw\n");
301 		kfree(sst->fw_in_mem);
302 		sst->fw_in_mem = NULL;
303 	}
304 
305 end_release:
306 	release_firmware(fw);
307 	return retval;
308 
309 }
310 
sst_firmware_load_cb(const struct firmware * fw,void * context)311 void sst_firmware_load_cb(const struct firmware *fw, void *context)
312 {
313 	struct intel_sst_drv *ctx = context;
314 
315 	dev_dbg(ctx->dev, "Enter\n");
316 
317 	if (fw == NULL) {
318 		dev_err(ctx->dev, "request fw failed\n");
319 		return;
320 	}
321 
322 	mutex_lock(&ctx->sst_lock);
323 
324 	if (ctx->sst_state != SST_RESET ||
325 			ctx->fw_in_mem != NULL) {
326 		release_firmware(fw);
327 		mutex_unlock(&ctx->sst_lock);
328 		return;
329 	}
330 
331 	dev_dbg(ctx->dev, "Request Fw completed\n");
332 	sst_cache_and_parse_fw(ctx, fw);
333 	mutex_unlock(&ctx->sst_lock);
334 }
335 
336 /*
337  * sst_request_fw - requests audio fw from kernel and saves a copy
338  *
339  * This function requests the SST FW from the kernel, parses it and
340  * saves a copy in the driver context
341  */
sst_request_fw(struct intel_sst_drv * sst)342 static int sst_request_fw(struct intel_sst_drv *sst)
343 {
344 	int retval = 0;
345 	const struct firmware *fw;
346 
347 	retval = request_firmware(&fw, sst->firmware_name, sst->dev);
348 	if (retval) {
349 		dev_err(sst->dev, "request fw failed %d\n", retval);
350 		return retval;
351 	}
352 	if (fw == NULL) {
353 		dev_err(sst->dev, "fw is returning as null\n");
354 		return -EINVAL;
355 	}
356 	mutex_lock(&sst->sst_lock);
357 	retval = sst_cache_and_parse_fw(sst, fw);
358 	mutex_unlock(&sst->sst_lock);
359 
360 	return retval;
361 }
362 
363 /*
364  * Writing the DDR physical base to DCCM offset
365  * so that FW can use it to setup TLB
366  */
sst_dccm_config_write(void __iomem * dram_base,unsigned int ddr_base)367 static void sst_dccm_config_write(void __iomem *dram_base,
368 		unsigned int ddr_base)
369 {
370 	void __iomem *addr;
371 	u32 bss_reset = 0;
372 
373 	addr = (void __iomem *)(dram_base + MRFLD_FW_DDR_BASE_OFFSET);
374 	memcpy32_toio(addr, (void *)&ddr_base, sizeof(u32));
375 	bss_reset |= (1 << MRFLD_FW_BSS_RESET_BIT);
376 	addr = (void __iomem *)(dram_base + MRFLD_FW_FEATURE_BASE_OFFSET);
377 	memcpy32_toio(addr, &bss_reset, sizeof(u32));
378 
379 }
380 
sst_post_download_mrfld(struct intel_sst_drv * ctx)381 void sst_post_download_mrfld(struct intel_sst_drv *ctx)
382 {
383 	sst_dccm_config_write(ctx->dram, ctx->ddr_base);
384 	dev_dbg(ctx->dev, "config written to DCCM\n");
385 }
386 
387 /**
388  * sst_load_fw - function to load FW into DSP
389  * @sst_drv_ctx: intel_sst_drv context pointer
390  *
391  * Transfers the FW to DSP using dma/memcpy
392  */
sst_load_fw(struct intel_sst_drv * sst_drv_ctx)393 int sst_load_fw(struct intel_sst_drv *sst_drv_ctx)
394 {
395 	int ret_val = 0;
396 	struct sst_block *block;
397 
398 	dev_dbg(sst_drv_ctx->dev, "sst_load_fw\n");
399 
400 	if (sst_drv_ctx->sst_state !=  SST_RESET)
401 		return -EAGAIN;
402 
403 	if (!sst_drv_ctx->fw_in_mem) {
404 		dev_dbg(sst_drv_ctx->dev, "sst: FW not in memory retry to download\n");
405 		ret_val = sst_request_fw(sst_drv_ctx);
406 		if (ret_val)
407 			return ret_val;
408 	}
409 
410 	block = sst_create_block(sst_drv_ctx, 0, FW_DWNL_ID);
411 	if (block == NULL)
412 		return -ENOMEM;
413 
414 	/* Prevent C-states beyond C6 */
415 	cpu_latency_qos_update_request(sst_drv_ctx->qos, 0);
416 
417 	sst_drv_ctx->sst_state = SST_FW_LOADING;
418 
419 	ret_val = sst_drv_ctx->ops->reset(sst_drv_ctx);
420 	if (ret_val)
421 		goto restore;
422 
423 	sst_do_memcpy(&sst_drv_ctx->memcpy_list);
424 
425 	/* Write the DRAM/DCCM config before enabling FW */
426 	if (sst_drv_ctx->ops->post_download)
427 		sst_drv_ctx->ops->post_download(sst_drv_ctx);
428 
429 	/* bring sst out of reset */
430 	ret_val = sst_drv_ctx->ops->start(sst_drv_ctx);
431 	if (ret_val)
432 		goto restore;
433 
434 	ret_val = sst_wait_timeout(sst_drv_ctx, block);
435 	if (ret_val) {
436 		dev_err(sst_drv_ctx->dev, "fw download failed %d\n" , ret_val);
437 		/* FW download failed due to timeout */
438 		ret_val = -EBUSY;
439 
440 	}
441 
442 
443 restore:
444 	/* Re-enable Deeper C-states beyond C6 */
445 	cpu_latency_qos_update_request(sst_drv_ctx->qos, PM_QOS_DEFAULT_VALUE);
446 	sst_free_block(sst_drv_ctx, block);
447 	dev_dbg(sst_drv_ctx->dev, "fw load successful!!!\n");
448 
449 	if (sst_drv_ctx->ops->restore_dsp_context)
450 		sst_drv_ctx->ops->restore_dsp_context();
451 	sst_drv_ctx->sst_state = SST_FW_RUNNING;
452 	return ret_val;
453 }
454 
455