1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
2 //
3 // This file is provided under a dual BSD/GPLv2 license.  When using or
4 // redistributing this file, you may do so under either license.
5 //
6 // Copyright(c) 2018 Intel Corporation. All rights reserved.
7 //
8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
9 //
10 // Generic debug routines used to export DSP MMIO and memories to userspace
11 // for firmware debugging.
12 //
13 
14 #include <linux/debugfs.h>
15 #include <linux/io.h>
16 #include <linux/pm_runtime.h>
17 #include <sound/sof/ext_manifest.h>
18 #include <sound/sof/debug.h>
19 #include "sof-priv.h"
20 #include "ops.h"
21 
sof_dfsentry_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)22 static ssize_t sof_dfsentry_write(struct file *file, const char __user *buffer,
23 				  size_t count, loff_t *ppos)
24 {
25 	size_t size;
26 	char *string;
27 	int ret;
28 
29 	string = kzalloc(count+1, GFP_KERNEL);
30 	if (!string)
31 		return -ENOMEM;
32 
33 	size = simple_write_to_buffer(string, count, ppos, buffer, count);
34 	ret = size;
35 
36 	kfree(string);
37 	return ret;
38 }
39 
sof_dfsentry_read(struct file * file,char __user * buffer,size_t count,loff_t * ppos)40 static ssize_t sof_dfsentry_read(struct file *file, char __user *buffer,
41 				 size_t count, loff_t *ppos)
42 {
43 	struct snd_sof_dfsentry *dfse = file->private_data;
44 	struct snd_sof_dev *sdev = dfse->sdev;
45 	loff_t pos = *ppos;
46 	size_t size_ret;
47 	int skip = 0;
48 	int size;
49 	u8 *buf;
50 
51 	size = dfse->size;
52 
53 	/* validate position & count */
54 	if (pos < 0)
55 		return -EINVAL;
56 	if (pos >= size || !count)
57 		return 0;
58 	/* find the minimum. min() is not used since it adds sparse warnings */
59 	if (count > size - pos)
60 		count = size - pos;
61 
62 	/* align io read start to u32 multiple */
63 	pos = ALIGN_DOWN(pos, 4);
64 
65 	/* intermediate buffer size must be u32 multiple */
66 	size = ALIGN(count, 4);
67 
68 	/* if start position is unaligned, read extra u32 */
69 	if (unlikely(pos != *ppos)) {
70 		skip = *ppos - pos;
71 		if (pos + size + 4 < dfse->size)
72 			size += 4;
73 	}
74 
75 	buf = kzalloc(size, GFP_KERNEL);
76 	if (!buf)
77 		return -ENOMEM;
78 
79 	if (dfse->type == SOF_DFSENTRY_TYPE_IOMEM) {
80 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE)
81 		/*
82 		 * If the DSP is active: copy from IO.
83 		 * If the DSP is suspended:
84 		 *	- Copy from IO if the memory is always accessible.
85 		 *	- Otherwise, copy from cached buffer.
86 		 */
87 		if (pm_runtime_active(sdev->dev) ||
88 		    dfse->access_type == SOF_DEBUGFS_ACCESS_ALWAYS) {
89 			memcpy_fromio(buf, dfse->io_mem + pos, size);
90 		} else {
91 			dev_info(sdev->dev,
92 				 "Copying cached debugfs data\n");
93 			memcpy(buf, dfse->cache_buf + pos, size);
94 		}
95 #else
96 		/* if the DSP is in D3 */
97 		if (!pm_runtime_active(sdev->dev) &&
98 		    dfse->access_type == SOF_DEBUGFS_ACCESS_D0_ONLY) {
99 			dev_err(sdev->dev,
100 				"error: debugfs entry cannot be read in DSP D3\n");
101 			kfree(buf);
102 			return -EINVAL;
103 		}
104 
105 		memcpy_fromio(buf, dfse->io_mem + pos, size);
106 #endif
107 	} else {
108 		memcpy(buf, ((u8 *)(dfse->buf) + pos), size);
109 	}
110 
111 	/* copy to userspace */
112 	size_ret = copy_to_user(buffer, buf + skip, count);
113 
114 	kfree(buf);
115 
116 	/* update count & position if copy succeeded */
117 	if (size_ret)
118 		return -EFAULT;
119 
120 	*ppos = pos + count;
121 
122 	return count;
123 }
124 
125 static const struct file_operations sof_dfs_fops = {
126 	.open = simple_open,
127 	.read = sof_dfsentry_read,
128 	.llseek = default_llseek,
129 	.write = sof_dfsentry_write,
130 };
131 
132 /* create FS entry for debug files that can expose DSP memories, registers */
snd_sof_debugfs_io_item(struct snd_sof_dev * sdev,void __iomem * base,size_t size,const char * name,enum sof_debugfs_access_type access_type)133 static int snd_sof_debugfs_io_item(struct snd_sof_dev *sdev,
134 				   void __iomem *base, size_t size,
135 				   const char *name,
136 				   enum sof_debugfs_access_type access_type)
137 {
138 	struct snd_sof_dfsentry *dfse;
139 
140 	if (!sdev)
141 		return -EINVAL;
142 
143 	dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL);
144 	if (!dfse)
145 		return -ENOMEM;
146 
147 	dfse->type = SOF_DFSENTRY_TYPE_IOMEM;
148 	dfse->io_mem = base;
149 	dfse->size = size;
150 	dfse->sdev = sdev;
151 	dfse->access_type = access_type;
152 
153 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE)
154 	/*
155 	 * allocate cache buffer that will be used to save the mem window
156 	 * contents prior to suspend
157 	 */
158 	if (access_type == SOF_DEBUGFS_ACCESS_D0_ONLY) {
159 		dfse->cache_buf = devm_kzalloc(sdev->dev, size, GFP_KERNEL);
160 		if (!dfse->cache_buf)
161 			return -ENOMEM;
162 	}
163 #endif
164 
165 	debugfs_create_file(name, 0444, sdev->debugfs_root, dfse,
166 			    &sof_dfs_fops);
167 
168 	/* add to dfsentry list */
169 	list_add(&dfse->list, &sdev->dfsentry_list);
170 
171 	return 0;
172 }
173 
snd_sof_debugfs_add_region_item_iomem(struct snd_sof_dev * sdev,enum snd_sof_fw_blk_type blk_type,u32 offset,size_t size,const char * name,enum sof_debugfs_access_type access_type)174 int snd_sof_debugfs_add_region_item_iomem(struct snd_sof_dev *sdev,
175 					  enum snd_sof_fw_blk_type blk_type, u32 offset,
176 					  size_t size, const char *name,
177 					  enum sof_debugfs_access_type access_type)
178 {
179 	int bar = snd_sof_dsp_get_bar_index(sdev, blk_type);
180 
181 	if (bar < 0)
182 		return bar;
183 
184 	return snd_sof_debugfs_io_item(sdev, sdev->bar[bar] + offset, size, name,
185 				       access_type);
186 }
187 EXPORT_SYMBOL_GPL(snd_sof_debugfs_add_region_item_iomem);
188 
189 /* create FS entry for debug files to expose kernel memory */
snd_sof_debugfs_buf_item(struct snd_sof_dev * sdev,void * base,size_t size,const char * name,mode_t mode)190 int snd_sof_debugfs_buf_item(struct snd_sof_dev *sdev,
191 			     void *base, size_t size,
192 			     const char *name, mode_t mode)
193 {
194 	struct snd_sof_dfsentry *dfse;
195 
196 	if (!sdev)
197 		return -EINVAL;
198 
199 	dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL);
200 	if (!dfse)
201 		return -ENOMEM;
202 
203 	dfse->type = SOF_DFSENTRY_TYPE_BUF;
204 	dfse->buf = base;
205 	dfse->size = size;
206 	dfse->sdev = sdev;
207 
208 	debugfs_create_file(name, mode, sdev->debugfs_root, dfse,
209 			    &sof_dfs_fops);
210 	/* add to dfsentry list */
211 	list_add(&dfse->list, &sdev->dfsentry_list);
212 
213 	return 0;
214 }
215 EXPORT_SYMBOL_GPL(snd_sof_debugfs_buf_item);
216 
memory_info_update(struct snd_sof_dev * sdev,char * buf,size_t buff_size)217 static int memory_info_update(struct snd_sof_dev *sdev, char *buf, size_t buff_size)
218 {
219 	struct sof_ipc_cmd_hdr msg = {
220 		.size = sizeof(struct sof_ipc_cmd_hdr),
221 		.cmd = SOF_IPC_GLB_DEBUG | SOF_IPC_DEBUG_MEM_USAGE,
222 	};
223 	struct sof_ipc_dbg_mem_usage *reply;
224 	int len;
225 	int ret;
226 	int i;
227 
228 	reply = kmalloc(SOF_IPC_MSG_MAX_SIZE, GFP_KERNEL);
229 	if (!reply)
230 		return -ENOMEM;
231 
232 	ret = pm_runtime_resume_and_get(sdev->dev);
233 	if (ret < 0 && ret != -EACCES) {
234 		dev_err(sdev->dev, "error: enabling device failed: %d\n", ret);
235 		goto error;
236 	}
237 
238 	ret = sof_ipc_tx_message(sdev->ipc, &msg, msg.size, reply, SOF_IPC_MSG_MAX_SIZE);
239 	pm_runtime_mark_last_busy(sdev->dev);
240 	pm_runtime_put_autosuspend(sdev->dev);
241 	if (ret < 0 || reply->rhdr.error < 0) {
242 		ret = min(ret, reply->rhdr.error);
243 		dev_err(sdev->dev, "error: reading memory info failed, %d\n", ret);
244 		goto error;
245 	}
246 
247 	if (struct_size(reply, elems, reply->num_elems) != reply->rhdr.hdr.size) {
248 		dev_err(sdev->dev, "error: invalid memory info ipc struct size, %d\n",
249 			reply->rhdr.hdr.size);
250 		ret = -EINVAL;
251 		goto error;
252 	}
253 
254 	for (i = 0, len = 0; i < reply->num_elems; i++) {
255 		ret = scnprintf(buf + len, buff_size - len, "zone %d.%d used %#8x free %#8x\n",
256 				reply->elems[i].zone, reply->elems[i].id,
257 				reply->elems[i].used, reply->elems[i].free);
258 		if (ret < 0)
259 			goto error;
260 		len += ret;
261 	}
262 
263 	ret = len;
264 error:
265 	kfree(reply);
266 	return ret;
267 }
268 
memory_info_read(struct file * file,char __user * to,size_t count,loff_t * ppos)269 static ssize_t memory_info_read(struct file *file, char __user *to, size_t count, loff_t *ppos)
270 {
271 	struct snd_sof_dfsentry *dfse = file->private_data;
272 	struct snd_sof_dev *sdev = dfse->sdev;
273 	int data_length;
274 
275 	/* read memory info from FW only once for each file read */
276 	if (!*ppos) {
277 		dfse->buf_data_size = 0;
278 		data_length = memory_info_update(sdev, dfse->buf, dfse->size);
279 		if (data_length < 0)
280 			return data_length;
281 		dfse->buf_data_size = data_length;
282 	}
283 
284 	return simple_read_from_buffer(to, count, ppos, dfse->buf, dfse->buf_data_size);
285 }
286 
memory_info_open(struct inode * inode,struct file * file)287 static int memory_info_open(struct inode *inode, struct file *file)
288 {
289 	struct snd_sof_dfsentry *dfse = inode->i_private;
290 	struct snd_sof_dev *sdev = dfse->sdev;
291 
292 	file->private_data = dfse;
293 
294 	/* allocate buffer memory only in first open run, to save memory when unused */
295 	if (!dfse->buf) {
296 		dfse->buf = devm_kmalloc(sdev->dev, PAGE_SIZE, GFP_KERNEL);
297 		if (!dfse->buf)
298 			return -ENOMEM;
299 		dfse->size = PAGE_SIZE;
300 	}
301 
302 	return 0;
303 }
304 
305 static const struct file_operations memory_info_fops = {
306 	.open = memory_info_open,
307 	.read = memory_info_read,
308 	.llseek = default_llseek,
309 };
310 
snd_sof_dbg_memory_info_init(struct snd_sof_dev * sdev)311 int snd_sof_dbg_memory_info_init(struct snd_sof_dev *sdev)
312 {
313 	struct snd_sof_dfsentry *dfse;
314 
315 	dfse = devm_kzalloc(sdev->dev, sizeof(*dfse), GFP_KERNEL);
316 	if (!dfse)
317 		return -ENOMEM;
318 
319 	/* don't allocate buffer before first usage, to save memory when unused */
320 	dfse->type = SOF_DFSENTRY_TYPE_BUF;
321 	dfse->sdev = sdev;
322 
323 	debugfs_create_file("memory_info", 0444, sdev->debugfs_root, dfse, &memory_info_fops);
324 
325 	/* add to dfsentry list */
326 	list_add(&dfse->list, &sdev->dfsentry_list);
327 	return 0;
328 }
329 EXPORT_SYMBOL_GPL(snd_sof_dbg_memory_info_init);
330 
snd_sof_dbg_init(struct snd_sof_dev * sdev)331 int snd_sof_dbg_init(struct snd_sof_dev *sdev)
332 {
333 	struct snd_sof_dsp_ops *ops = sof_ops(sdev);
334 	const struct snd_sof_debugfs_map *map;
335 	int i;
336 	int err;
337 
338 	/* use "sof" as top level debugFS dir */
339 	sdev->debugfs_root = debugfs_create_dir("sof", NULL);
340 
341 	/* init dfsentry list */
342 	INIT_LIST_HEAD(&sdev->dfsentry_list);
343 
344 	/* create debugFS files for platform specific MMIO/DSP memories */
345 	for (i = 0; i < ops->debug_map_count; i++) {
346 		map = &ops->debug_map[i];
347 
348 		err = snd_sof_debugfs_io_item(sdev, sdev->bar[map->bar] +
349 					      map->offset, map->size,
350 					      map->name, map->access_type);
351 		/* errors are only due to memory allocation, not debugfs */
352 		if (err < 0)
353 			return err;
354 	}
355 
356 	return snd_sof_debugfs_buf_item(sdev, &sdev->fw_state,
357 					sizeof(sdev->fw_state),
358 					"fw_state", 0444);
359 }
360 EXPORT_SYMBOL_GPL(snd_sof_dbg_init);
361 
snd_sof_free_debug(struct snd_sof_dev * sdev)362 void snd_sof_free_debug(struct snd_sof_dev *sdev)
363 {
364 	debugfs_remove_recursive(sdev->debugfs_root);
365 }
366 EXPORT_SYMBOL_GPL(snd_sof_free_debug);
367 
368 static const struct soc_fw_state_info {
369 	enum sof_fw_state state;
370 	const char *name;
371 } fw_state_dbg[] = {
372 	{SOF_FW_BOOT_NOT_STARTED, "SOF_FW_BOOT_NOT_STARTED"},
373 	{SOF_FW_BOOT_PREPARE, "SOF_FW_BOOT_PREPARE"},
374 	{SOF_FW_BOOT_IN_PROGRESS, "SOF_FW_BOOT_IN_PROGRESS"},
375 	{SOF_FW_BOOT_FAILED, "SOF_FW_BOOT_FAILED"},
376 	{SOF_FW_BOOT_READY_FAILED, "SOF_FW_BOOT_READY_FAILED"},
377 	{SOF_FW_BOOT_READY_OK, "SOF_FW_BOOT_READY_OK"},
378 	{SOF_FW_BOOT_COMPLETE, "SOF_FW_BOOT_COMPLETE"},
379 	{SOF_FW_CRASHED, "SOF_FW_CRASHED"},
380 };
381 
snd_sof_dbg_print_fw_state(struct snd_sof_dev * sdev,const char * level)382 static void snd_sof_dbg_print_fw_state(struct snd_sof_dev *sdev, const char *level)
383 {
384 	int i;
385 
386 	for (i = 0; i < ARRAY_SIZE(fw_state_dbg); i++) {
387 		if (sdev->fw_state == fw_state_dbg[i].state) {
388 			dev_printk(level, sdev->dev, "fw_state: %s (%d)\n",
389 				   fw_state_dbg[i].name, i);
390 			return;
391 		}
392 	}
393 
394 	dev_printk(level, sdev->dev, "fw_state: UNKNOWN (%d)\n", sdev->fw_state);
395 }
396 
snd_sof_dsp_dbg_dump(struct snd_sof_dev * sdev,const char * msg,u32 flags)397 void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, const char *msg, u32 flags)
398 {
399 	char *level = (flags & SOF_DBG_DUMP_OPTIONAL) ? KERN_DEBUG : KERN_ERR;
400 	bool print_all = sof_debug_check_flag(SOF_DBG_PRINT_ALL_DUMPS);
401 
402 	if (flags & SOF_DBG_DUMP_OPTIONAL && !print_all)
403 		return;
404 
405 	if (sof_ops(sdev)->dbg_dump && !sdev->dbg_dump_printed) {
406 		dev_printk(level, sdev->dev,
407 			   "------------[ DSP dump start ]------------\n");
408 		if (msg)
409 			dev_printk(level, sdev->dev, "%s\n", msg);
410 		snd_sof_dbg_print_fw_state(sdev, level);
411 		sof_ops(sdev)->dbg_dump(sdev, flags);
412 		dev_printk(level, sdev->dev,
413 			   "------------[ DSP dump end ]------------\n");
414 		if (!print_all)
415 			sdev->dbg_dump_printed = true;
416 	} else if (msg) {
417 		dev_printk(level, sdev->dev, "%s\n", msg);
418 	}
419 }
420 EXPORT_SYMBOL(snd_sof_dsp_dbg_dump);
421 
snd_sof_ipc_dump(struct snd_sof_dev * sdev)422 static void snd_sof_ipc_dump(struct snd_sof_dev *sdev)
423 {
424 	if (sof_ops(sdev)->ipc_dump  && !sdev->ipc_dump_printed) {
425 		dev_err(sdev->dev, "------------[ IPC dump start ]------------\n");
426 		sof_ops(sdev)->ipc_dump(sdev);
427 		dev_err(sdev->dev, "------------[ IPC dump end ]------------\n");
428 		if (!sof_debug_check_flag(SOF_DBG_PRINT_ALL_DUMPS))
429 			sdev->ipc_dump_printed = true;
430 	}
431 }
432 
snd_sof_handle_fw_exception(struct snd_sof_dev * sdev,const char * msg)433 void snd_sof_handle_fw_exception(struct snd_sof_dev *sdev, const char *msg)
434 {
435 	if (IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_RETAIN_DSP_CONTEXT) ||
436 	    sof_debug_check_flag(SOF_DBG_RETAIN_CTX)) {
437 		/* should we prevent DSP entering D3 ? */
438 		if (!sdev->ipc_dump_printed)
439 			dev_info(sdev->dev,
440 				 "preventing DSP entering D3 state to preserve context\n");
441 		pm_runtime_get_noresume(sdev->dev);
442 	}
443 
444 	/* dump vital information to the logs */
445 	snd_sof_ipc_dump(sdev);
446 	snd_sof_dsp_dbg_dump(sdev, msg, SOF_DBG_DUMP_REGS | SOF_DBG_DUMP_MBOX);
447 	sof_fw_trace_fw_crashed(sdev);
448 }
449 EXPORT_SYMBOL(snd_sof_handle_fw_exception);
450