1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright(c) 2021-2022 Intel Corporation
4 //
5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
7 //
8
9 #include <linux/debugfs.h>
10 #include <linux/kfifo.h>
11 #include <linux/wait.h>
12 #include <linux/sched/signal.h>
13 #include <linux/string_helpers.h>
14 #include <sound/soc.h>
15 #include "avs.h"
16 #include "messages.h"
17
__kfifo_fromio(struct kfifo * fifo,const void __iomem * src,unsigned int len)18 static unsigned int __kfifo_fromio(struct kfifo *fifo, const void __iomem *src, unsigned int len)
19 {
20 struct __kfifo *__fifo = &fifo->kfifo;
21 unsigned int l, off;
22
23 len = min(len, kfifo_avail(fifo));
24 off = __fifo->in & __fifo->mask;
25 l = min(len, kfifo_size(fifo) - off);
26
27 memcpy_fromio(__fifo->data + off, src, l);
28 memcpy_fromio(__fifo->data, src + l, len - l);
29 /* Make sure data copied from SRAM is visible to all CPUs. */
30 smp_mb();
31 __fifo->in += len;
32
33 return len;
34 }
35
avs_logging_fw(struct avs_dev * adev)36 bool avs_logging_fw(struct avs_dev *adev)
37 {
38 return kfifo_initialized(&adev->trace_fifo);
39 }
40
avs_dump_fw_log(struct avs_dev * adev,const void __iomem * src,unsigned int len)41 void avs_dump_fw_log(struct avs_dev *adev, const void __iomem *src, unsigned int len)
42 {
43 __kfifo_fromio(&adev->trace_fifo, src, len);
44 }
45
avs_dump_fw_log_wakeup(struct avs_dev * adev,const void __iomem * src,unsigned int len)46 void avs_dump_fw_log_wakeup(struct avs_dev *adev, const void __iomem *src, unsigned int len)
47 {
48 avs_dump_fw_log(adev, src, len);
49 wake_up(&adev->trace_waitq);
50 }
51
fw_regs_read(struct file * file,char __user * to,size_t count,loff_t * ppos)52 static ssize_t fw_regs_read(struct file *file, char __user *to, size_t count, loff_t *ppos)
53 {
54 struct avs_dev *adev = file->private_data;
55 char *buf;
56 int ret;
57
58 buf = kzalloc(AVS_FW_REGS_SIZE, GFP_KERNEL);
59 if (!buf)
60 return -ENOMEM;
61
62 memcpy_fromio(buf, avs_sram_addr(adev, AVS_FW_REGS_WINDOW), AVS_FW_REGS_SIZE);
63
64 ret = simple_read_from_buffer(to, count, ppos, buf, AVS_FW_REGS_SIZE);
65 kfree(buf);
66 return ret;
67 }
68
69 static const struct file_operations fw_regs_fops = {
70 .open = simple_open,
71 .read = fw_regs_read,
72 };
73
debug_window_read(struct file * file,char __user * to,size_t count,loff_t * ppos)74 static ssize_t debug_window_read(struct file *file, char __user *to, size_t count, loff_t *ppos)
75 {
76 struct avs_dev *adev = file->private_data;
77 size_t size;
78 char *buf;
79 int ret;
80
81 size = adev->hw_cfg.dsp_cores * AVS_WINDOW_CHUNK_SIZE;
82 buf = kzalloc(size, GFP_KERNEL);
83 if (!buf)
84 return -ENOMEM;
85
86 memcpy_fromio(buf, avs_sram_addr(adev, AVS_DEBUG_WINDOW), size);
87
88 ret = simple_read_from_buffer(to, count, ppos, buf, size);
89 kfree(buf);
90 return ret;
91 }
92
93 static const struct file_operations debug_window_fops = {
94 .open = simple_open,
95 .read = debug_window_read,
96 };
97
probe_points_read(struct file * file,char __user * to,size_t count,loff_t * ppos)98 static ssize_t probe_points_read(struct file *file, char __user *to, size_t count, loff_t *ppos)
99 {
100 struct avs_dev *adev = file->private_data;
101 struct avs_probe_point_desc *desc;
102 size_t num_desc, len = 0;
103 char *buf;
104 int i, ret;
105
106 /* Prevent chaining, send and dump IPC value just once. */
107 if (*ppos)
108 return 0;
109
110 buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
111 if (!buf)
112 return -ENOMEM;
113
114 ret = avs_ipc_probe_get_points(adev, &desc, &num_desc);
115 if (ret) {
116 ret = AVS_IPC_RET(ret);
117 goto exit;
118 }
119
120 for (i = 0; i < num_desc; i++) {
121 ret = snprintf(buf + len, PAGE_SIZE - len,
122 "Id: %#010x Purpose: %d Node id: %#x\n",
123 desc[i].id.value, desc[i].purpose, desc[i].node_id.val);
124 if (ret < 0)
125 goto free_desc;
126 len += ret;
127 }
128
129 ret = simple_read_from_buffer(to, count, ppos, buf, len);
130 free_desc:
131 kfree(desc);
132 exit:
133 kfree(buf);
134 return ret;
135 }
136
probe_points_write(struct file * file,const char __user * from,size_t count,loff_t * ppos)137 static ssize_t probe_points_write(struct file *file, const char __user *from, size_t count,
138 loff_t *ppos)
139 {
140 struct avs_dev *adev = file->private_data;
141 struct avs_probe_point_desc *desc;
142 u32 *array, num_elems;
143 size_t bytes;
144 int ret;
145
146 ret = parse_int_array_user(from, count, (int **)&array);
147 if (ret)
148 return ret;
149
150 num_elems = *array;
151 bytes = sizeof(*array) * num_elems;
152 if (bytes % sizeof(*desc)) {
153 ret = -EINVAL;
154 goto exit;
155 }
156
157 desc = (struct avs_probe_point_desc *)&array[1];
158 ret = avs_ipc_probe_connect_points(adev, desc, bytes / sizeof(*desc));
159 if (ret)
160 ret = AVS_IPC_RET(ret);
161 else
162 ret = count;
163 exit:
164 kfree(array);
165 return ret;
166 }
167
168 static const struct file_operations probe_points_fops = {
169 .open = simple_open,
170 .read = probe_points_read,
171 .write = probe_points_write,
172 };
173
probe_points_disconnect_write(struct file * file,const char __user * from,size_t count,loff_t * ppos)174 static ssize_t probe_points_disconnect_write(struct file *file, const char __user *from,
175 size_t count, loff_t *ppos)
176 {
177 struct avs_dev *adev = file->private_data;
178 union avs_probe_point_id *id;
179 u32 *array, num_elems;
180 size_t bytes;
181 int ret;
182
183 ret = parse_int_array_user(from, count, (int **)&array);
184 if (ret)
185 return ret;
186
187 num_elems = *array;
188 bytes = sizeof(*array) * num_elems;
189 if (bytes % sizeof(*id)) {
190 ret = -EINVAL;
191 goto exit;
192 }
193
194 id = (union avs_probe_point_id *)&array[1];
195 ret = avs_ipc_probe_disconnect_points(adev, id, bytes / sizeof(*id));
196 if (ret)
197 ret = AVS_IPC_RET(ret);
198 else
199 ret = count;
200 exit:
201 kfree(array);
202 return ret;
203 }
204
205 static const struct file_operations probe_points_disconnect_fops = {
206 .open = simple_open,
207 .write = probe_points_disconnect_write,
208 .llseek = default_llseek,
209 };
210
strace_read(struct file * file,char __user * to,size_t count,loff_t * ppos)211 static ssize_t strace_read(struct file *file, char __user *to, size_t count, loff_t *ppos)
212 {
213 struct avs_dev *adev = file->private_data;
214 struct kfifo *fifo = &adev->trace_fifo;
215 unsigned int copied;
216
217 if (kfifo_is_empty(fifo)) {
218 DEFINE_WAIT(wait);
219
220 prepare_to_wait(&adev->trace_waitq, &wait, TASK_INTERRUPTIBLE);
221 if (!signal_pending(current))
222 schedule();
223 finish_wait(&adev->trace_waitq, &wait);
224 }
225
226 if (kfifo_to_user(fifo, to, count, &copied))
227 return -EFAULT;
228 *ppos += copied;
229 return copied;
230 }
231
strace_open(struct inode * inode,struct file * file)232 static int strace_open(struct inode *inode, struct file *file)
233 {
234 struct avs_dev *adev = inode->i_private;
235 int ret;
236
237 if (!try_module_get(adev->dev->driver->owner))
238 return -ENODEV;
239
240 if (kfifo_initialized(&adev->trace_fifo))
241 return -EBUSY;
242
243 ret = kfifo_alloc(&adev->trace_fifo, PAGE_SIZE, GFP_KERNEL);
244 if (ret < 0)
245 return ret;
246
247 file->private_data = adev;
248 return 0;
249 }
250
strace_release(struct inode * inode,struct file * file)251 static int strace_release(struct inode *inode, struct file *file)
252 {
253 union avs_notify_msg msg = AVS_NOTIFICATION(LOG_BUFFER_STATUS);
254 struct avs_dev *adev = file->private_data;
255 unsigned long resource_mask;
256 unsigned long flags, i;
257 u32 num_cores;
258
259 resource_mask = adev->logged_resources;
260 num_cores = adev->hw_cfg.dsp_cores;
261
262 spin_lock_irqsave(&adev->trace_lock, flags);
263
264 /* Gather any remaining logs. */
265 for_each_set_bit(i, &resource_mask, num_cores) {
266 msg.log.core = i;
267 avs_dsp_op(adev, log_buffer_status, &msg);
268 }
269
270 kfifo_free(&adev->trace_fifo);
271
272 spin_unlock_irqrestore(&adev->trace_lock, flags);
273
274 module_put(adev->dev->driver->owner);
275 return 0;
276 }
277
278 static const struct file_operations strace_fops = {
279 .llseek = default_llseek,
280 .read = strace_read,
281 .open = strace_open,
282 .release = strace_release,
283 };
284
285 #define DISABLE_TIMERS UINT_MAX
286
enable_logs(struct avs_dev * adev,u32 resource_mask,u32 * priorities)287 static int enable_logs(struct avs_dev *adev, u32 resource_mask, u32 *priorities)
288 {
289 int ret;
290
291 /* Logging demands D0i0 state from DSP. */
292 if (!adev->logged_resources) {
293 pm_runtime_get_sync(adev->dev);
294
295 ret = avs_dsp_disable_d0ix(adev);
296 if (ret)
297 goto err_d0ix;
298 }
299
300 ret = avs_ipc_set_system_time(adev);
301 if (ret && ret != AVS_IPC_NOT_SUPPORTED) {
302 ret = AVS_IPC_RET(ret);
303 goto err_ipc;
304 }
305
306 ret = avs_dsp_op(adev, enable_logs, AVS_LOG_ENABLE, adev->aging_timer_period,
307 adev->fifo_full_timer_period, resource_mask, priorities);
308 if (ret)
309 goto err_ipc;
310
311 adev->logged_resources |= resource_mask;
312 return 0;
313
314 err_ipc:
315 if (!adev->logged_resources) {
316 avs_dsp_enable_d0ix(adev);
317 err_d0ix:
318 pm_runtime_put_autosuspend(adev->dev);
319 }
320
321 return ret;
322 }
323
disable_logs(struct avs_dev * adev,u32 resource_mask)324 static int disable_logs(struct avs_dev *adev, u32 resource_mask)
325 {
326 int ret;
327
328 /* Check if there's anything to do. */
329 if (!adev->logged_resources)
330 return 0;
331
332 ret = avs_dsp_op(adev, enable_logs, AVS_LOG_DISABLE, DISABLE_TIMERS, DISABLE_TIMERS,
333 resource_mask, NULL);
334
335 /*
336 * If IPC fails causing recovery, logged_resources is already zero
337 * so unsetting bits is still safe.
338 */
339 adev->logged_resources &= ~resource_mask;
340
341 /* If that's the last resource, allow for D3. */
342 if (!adev->logged_resources) {
343 avs_dsp_enable_d0ix(adev);
344 pm_runtime_put_autosuspend(adev->dev);
345 }
346
347 return ret;
348 }
349
trace_control_read(struct file * file,char __user * to,size_t count,loff_t * ppos)350 static ssize_t trace_control_read(struct file *file, char __user *to, size_t count, loff_t *ppos)
351 {
352 struct avs_dev *adev = file->private_data;
353 char buf[64];
354 int len;
355
356 len = snprintf(buf, sizeof(buf), "0x%08x\n", adev->logged_resources);
357
358 return simple_read_from_buffer(to, count, ppos, buf, len);
359 }
360
trace_control_write(struct file * file,const char __user * from,size_t count,loff_t * ppos)361 static ssize_t trace_control_write(struct file *file, const char __user *from, size_t count,
362 loff_t *ppos)
363 {
364 struct avs_dev *adev = file->private_data;
365 u32 *array, num_elems;
366 u32 resource_mask;
367 int ret;
368
369 ret = parse_int_array_user(from, count, (int **)&array);
370 if (ret)
371 return ret;
372
373 num_elems = *array;
374 if (!num_elems) {
375 ret = -EINVAL;
376 goto free_array;
377 }
378
379 /*
380 * Disable if just resource mask is provided - no log priority flags.
381 *
382 * Enable input format: mask, prio1, .., prioN
383 * Where 'N' equals number of bits set in the 'mask'.
384 */
385 resource_mask = array[1];
386 if (num_elems == 1) {
387 ret = disable_logs(adev, resource_mask);
388 } else {
389 if (num_elems != (hweight_long(resource_mask) + 1)) {
390 ret = -EINVAL;
391 goto free_array;
392 }
393
394 ret = enable_logs(adev, resource_mask, &array[2]);
395 }
396
397 if (!ret)
398 ret = count;
399 free_array:
400 kfree(array);
401 return ret;
402 }
403
404 static const struct file_operations trace_control_fops = {
405 .llseek = default_llseek,
406 .read = trace_control_read,
407 .write = trace_control_write,
408 .open = simple_open,
409 };
410
avs_debugfs_init(struct avs_dev * adev)411 void avs_debugfs_init(struct avs_dev *adev)
412 {
413 init_waitqueue_head(&adev->trace_waitq);
414 spin_lock_init(&adev->trace_lock);
415
416 adev->debugfs_root = debugfs_create_dir("avs", snd_soc_debugfs_root);
417
418 /* Initialize timer periods with recommended defaults. */
419 adev->aging_timer_period = 10;
420 adev->fifo_full_timer_period = 10;
421
422 debugfs_create_file("strace", 0444, adev->debugfs_root, adev, &strace_fops);
423 debugfs_create_file("trace_control", 0644, adev->debugfs_root, adev, &trace_control_fops);
424 debugfs_create_file("fw_regs", 0444, adev->debugfs_root, adev, &fw_regs_fops);
425 debugfs_create_file("debug_window", 0444, adev->debugfs_root, adev, &debug_window_fops);
426
427 debugfs_create_u32("trace_aging_period", 0644, adev->debugfs_root,
428 &adev->aging_timer_period);
429 debugfs_create_u32("trace_fifo_full_period", 0644, adev->debugfs_root,
430 &adev->fifo_full_timer_period);
431
432 debugfs_create_file("probe_points", 0644, adev->debugfs_root, adev, &probe_points_fops);
433 debugfs_create_file("probe_points_disconnect", 0200, adev->debugfs_root, adev,
434 &probe_points_disconnect_fops);
435 }
436
avs_debugfs_exit(struct avs_dev * adev)437 void avs_debugfs_exit(struct avs_dev *adev)
438 {
439 debugfs_remove_recursive(adev->debugfs_root);
440 }
441