| // SPDX-License-Identifier: GPL-2.0-only |
| // |
| // Copyright(c) 2021-2022 Intel Corporation. All rights reserved. |
| // |
| // Authors: Cezary Rojewski <cezary.rojewski@intel.com> |
| // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com> |
| // |
| |
| #include <linux/debugfs.h> |
| #include <linux/kfifo.h> |
| #include <linux/wait.h> |
| #include <linux/sched/signal.h> |
| #include <sound/soc.h> |
| #include "avs.h" |
| #include "messages.h" |
| |
| static unsigned int __kfifo_fromio(struct kfifo *fifo, const void __iomem *src, unsigned int len) |
| { |
| struct __kfifo *__fifo = &fifo->kfifo; |
| unsigned int l, off; |
| |
| len = min(len, kfifo_avail(fifo)); |
| off = __fifo->in & __fifo->mask; |
| l = min(len, kfifo_size(fifo) - off); |
| |
| memcpy_fromio(__fifo->data + off, src, l); |
| memcpy_fromio(__fifo->data, src + l, len - l); |
| /* Make sure data copied from SRAM is visible to all CPUs. */ |
| smp_mb(); |
| __fifo->in += len; |
| |
| return len; |
| } |
| |
| bool avs_logging_fw(struct avs_dev *adev) |
| { |
| return kfifo_initialized(&adev->trace_fifo); |
| } |
| |
| void avs_dump_fw_log(struct avs_dev *adev, const void __iomem *src, unsigned int len) |
| { |
| __kfifo_fromio(&adev->trace_fifo, src, len); |
| } |
| |
| void avs_dump_fw_log_wakeup(struct avs_dev *adev, const void __iomem *src, unsigned int len) |
| { |
| avs_dump_fw_log(adev, src, len); |
| wake_up(&adev->trace_waitq); |
| } |
| |
| static ssize_t fw_regs_read(struct file *file, char __user *to, size_t count, loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| char *buf; |
| int ret; |
| |
| buf = kzalloc(AVS_FW_REGS_SIZE, GFP_KERNEL); |
| if (!buf) |
| return -ENOMEM; |
| |
| memcpy_fromio(buf, avs_sram_addr(adev, AVS_FW_REGS_WINDOW), AVS_FW_REGS_SIZE); |
| |
| ret = simple_read_from_buffer(to, count, ppos, buf, AVS_FW_REGS_SIZE); |
| kfree(buf); |
| return ret; |
| } |
| |
| static const struct file_operations fw_regs_fops = { |
| .open = simple_open, |
| .read = fw_regs_read, |
| .llseek = no_llseek, |
| }; |
| |
| static ssize_t debug_window_read(struct file *file, char __user *to, size_t count, loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| size_t size; |
| char *buf; |
| int ret; |
| |
| size = adev->hw_cfg.dsp_cores * AVS_WINDOW_CHUNK_SIZE; |
| buf = kzalloc(size, GFP_KERNEL); |
| if (!buf) |
| return -ENOMEM; |
| |
| memcpy_fromio(buf, avs_sram_addr(adev, AVS_DEBUG_WINDOW), size); |
| |
| ret = simple_read_from_buffer(to, count, ppos, buf, size); |
| kfree(buf); |
| return ret; |
| } |
| |
| static const struct file_operations debug_window_fops = { |
| .open = simple_open, |
| .read = debug_window_read, |
| .llseek = no_llseek, |
| }; |
| |
| static ssize_t probe_points_read(struct file *file, char __user *to, size_t count, loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| struct avs_probe_point_desc *desc; |
| size_t num_desc, len = 0; |
| char *buf; |
| int i, ret; |
| |
| /* Prevent chaining, send and dump IPC value just once. */ |
| if (*ppos) |
| return 0; |
| |
| buf = kzalloc(PAGE_SIZE, GFP_KERNEL); |
| if (!buf) |
| return -ENOMEM; |
| |
| ret = avs_ipc_probe_get_points(adev, &desc, &num_desc); |
| if (ret) { |
| ret = AVS_IPC_RET(ret); |
| goto exit; |
| } |
| |
| for (i = 0; i < num_desc; i++) { |
| ret = snprintf(buf + len, PAGE_SIZE - len, |
| "Id: %#010x Purpose: %d Node id: %#x\n", |
| desc[i].id.value, desc[i].purpose, desc[i].node_id.val); |
| if (ret < 0) |
| goto free_desc; |
| len += ret; |
| } |
| |
| ret = simple_read_from_buffer(to, count, ppos, buf, len); |
| free_desc: |
| kfree(desc); |
| exit: |
| kfree(buf); |
| return ret; |
| } |
| |
| static ssize_t probe_points_write(struct file *file, const char __user *from, size_t count, |
| loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| struct avs_probe_point_desc *desc; |
| u32 *array, num_elems; |
| size_t bytes; |
| int ret; |
| |
| ret = parse_int_array_user(from, count, (int **)&array); |
| if (ret < 0) |
| return ret; |
| |
| num_elems = *array; |
| bytes = sizeof(*array) * num_elems; |
| if (bytes % sizeof(*desc)) { |
| ret = -EINVAL; |
| goto exit; |
| } |
| |
| desc = (struct avs_probe_point_desc *)&array[1]; |
| ret = avs_ipc_probe_connect_points(adev, desc, bytes / sizeof(*desc)); |
| if (ret) |
| ret = AVS_IPC_RET(ret); |
| else |
| ret = count; |
| exit: |
| kfree(array); |
| return ret; |
| } |
| |
| static const struct file_operations probe_points_fops = { |
| .open = simple_open, |
| .read = probe_points_read, |
| .write = probe_points_write, |
| .llseek = no_llseek, |
| }; |
| |
| static ssize_t probe_points_disconnect_write(struct file *file, const char __user *from, |
| size_t count, loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| union avs_probe_point_id *id; |
| u32 *array, num_elems; |
| size_t bytes; |
| int ret; |
| |
| ret = parse_int_array_user(from, count, (int **)&array); |
| if (ret < 0) |
| return ret; |
| |
| num_elems = *array; |
| bytes = sizeof(*array) * num_elems; |
| if (bytes % sizeof(*id)) { |
| ret = -EINVAL; |
| goto exit; |
| } |
| |
| id = (union avs_probe_point_id *)&array[1]; |
| ret = avs_ipc_probe_disconnect_points(adev, id, bytes / sizeof(*id)); |
| if (ret) |
| ret = AVS_IPC_RET(ret); |
| else |
| ret = count; |
| exit: |
| kfree(array); |
| return ret; |
| } |
| |
| static const struct file_operations probe_points_disconnect_fops = { |
| .open = simple_open, |
| .write = probe_points_disconnect_write, |
| .llseek = default_llseek, |
| }; |
| |
| static ssize_t strace_read(struct file *file, char __user *to, size_t count, loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| struct kfifo *fifo = &adev->trace_fifo; |
| unsigned int copied; |
| |
| if (kfifo_is_empty(fifo)) { |
| DEFINE_WAIT(wait); |
| |
| prepare_to_wait(&adev->trace_waitq, &wait, TASK_INTERRUPTIBLE); |
| if (!signal_pending(current)) |
| schedule(); |
| finish_wait(&adev->trace_waitq, &wait); |
| } |
| |
| if (kfifo_to_user(fifo, to, count, &copied)) |
| return -EFAULT; |
| *ppos += copied; |
| return copied; |
| } |
| |
| static int strace_open(struct inode *inode, struct file *file) |
| { |
| struct avs_dev *adev = inode->i_private; |
| int ret; |
| |
| if (!try_module_get(adev->dev->driver->owner)) |
| return -ENODEV; |
| |
| if (kfifo_initialized(&adev->trace_fifo)) |
| return -EBUSY; |
| |
| ret = kfifo_alloc(&adev->trace_fifo, PAGE_SIZE, GFP_KERNEL); |
| if (ret < 0) |
| return ret; |
| |
| file->private_data = adev; |
| return 0; |
| } |
| |
| static int strace_release(struct inode *inode, struct file *file) |
| { |
| union avs_notify_msg msg = AVS_NOTIFICATION(LOG_BUFFER_STATUS); |
| struct avs_dev *adev = file->private_data; |
| unsigned long resource_mask; |
| unsigned long flags, i; |
| u32 num_cores; |
| |
| resource_mask = adev->logged_resources; |
| num_cores = adev->hw_cfg.dsp_cores; |
| |
| spin_lock_irqsave(&adev->trace_lock, flags); |
| |
| /* Gather any remaining logs. */ |
| for_each_set_bit(i, &resource_mask, num_cores) { |
| msg.log.core = i; |
| avs_dsp_op(adev, log_buffer_status, &msg); |
| } |
| |
| kfifo_free(&adev->trace_fifo); |
| |
| spin_unlock_irqrestore(&adev->trace_lock, flags); |
| |
| module_put(adev->dev->driver->owner); |
| return 0; |
| } |
| |
| static const struct file_operations strace_fops = { |
| .llseek = default_llseek, |
| .read = strace_read, |
| .open = strace_open, |
| .release = strace_release, |
| }; |
| |
| #define DISABLE_TIMERS UINT_MAX |
| |
| static int enable_logs(struct avs_dev *adev, u32 resource_mask, u32 *priorities) |
| { |
| int ret; |
| |
| /* Logging demands D0i0 state from DSP. */ |
| if (!adev->logged_resources) { |
| pm_runtime_get_sync(adev->dev); |
| |
| ret = avs_dsp_disable_d0ix(adev); |
| if (ret) |
| goto err_d0ix; |
| } |
| |
| ret = avs_ipc_set_system_time(adev); |
| if (ret && ret != AVS_IPC_NOT_SUPPORTED) { |
| ret = AVS_IPC_RET(ret); |
| goto err_ipc; |
| } |
| |
| ret = avs_dsp_op(adev, enable_logs, AVS_LOG_ENABLE, adev->aging_timer_period, |
| adev->fifo_full_timer_period, resource_mask, priorities); |
| if (ret) |
| goto err_ipc; |
| |
| adev->logged_resources |= resource_mask; |
| return 0; |
| |
| err_ipc: |
| if (!adev->logged_resources) { |
| avs_dsp_enable_d0ix(adev); |
| err_d0ix: |
| pm_runtime_mark_last_busy(adev->dev); |
| pm_runtime_put_autosuspend(adev->dev); |
| } |
| |
| return ret; |
| } |
| |
| static int disable_logs(struct avs_dev *adev, u32 resource_mask) |
| { |
| int ret; |
| |
| /* Check if there's anything to do. */ |
| if (!adev->logged_resources) |
| return 0; |
| |
| ret = avs_dsp_op(adev, enable_logs, AVS_LOG_DISABLE, DISABLE_TIMERS, DISABLE_TIMERS, |
| resource_mask, NULL); |
| |
| /* |
| * If IPC fails causing recovery, logged_resources is already zero |
| * so unsetting bits is still safe. |
| */ |
| adev->logged_resources &= ~resource_mask; |
| |
| /* If that's the last resource, allow for D3. */ |
| if (!adev->logged_resources) { |
| avs_dsp_enable_d0ix(adev); |
| pm_runtime_mark_last_busy(adev->dev); |
| pm_runtime_put_autosuspend(adev->dev); |
| } |
| |
| return ret; |
| } |
| |
| static ssize_t trace_control_read(struct file *file, char __user *to, size_t count, loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| char buf[64]; |
| int len; |
| |
| len = snprintf(buf, sizeof(buf), "0x%08x\n", adev->logged_resources); |
| |
| return simple_read_from_buffer(to, count, ppos, buf, len); |
| } |
| |
| static ssize_t trace_control_write(struct file *file, const char __user *from, size_t count, |
| loff_t *ppos) |
| { |
| struct avs_dev *adev = file->private_data; |
| u32 *array, num_elems; |
| u32 resource_mask; |
| int ret; |
| |
| ret = parse_int_array_user(from, count, (int **)&array); |
| if (ret < 0) |
| return ret; |
| |
| num_elems = *array; |
| resource_mask = array[1]; |
| |
| /* |
| * Disable if just resource mask is provided - no log priority flags. |
| * |
| * Enable input format: mask, prio1, .., prioN |
| * Where 'N' equals number of bits set in the 'mask'. |
| */ |
| if (num_elems == 1) { |
| ret = disable_logs(adev, resource_mask); |
| } else { |
| if (num_elems != (hweight_long(resource_mask) + 1)) { |
| ret = -EINVAL; |
| goto free_array; |
| } |
| |
| ret = enable_logs(adev, resource_mask, &array[2]); |
| } |
| |
| if (!ret) |
| ret = count; |
| free_array: |
| kfree(array); |
| return ret; |
| } |
| |
| static const struct file_operations trace_control_fops = { |
| .llseek = default_llseek, |
| .read = trace_control_read, |
| .write = trace_control_write, |
| .open = simple_open, |
| }; |
| |
| void avs_debugfs_init(struct avs_dev *adev) |
| { |
| init_waitqueue_head(&adev->trace_waitq); |
| spin_lock_init(&adev->trace_lock); |
| |
| adev->debugfs_root = debugfs_create_dir("avs", snd_soc_debugfs_root); |
| |
| /* Initialize timer periods with recommended defaults. */ |
| adev->aging_timer_period = 10; |
| adev->fifo_full_timer_period = 10; |
| |
| debugfs_create_file("strace", 0444, adev->debugfs_root, adev, &strace_fops); |
| debugfs_create_file("trace_control", 0644, adev->debugfs_root, adev, &trace_control_fops); |
| debugfs_create_file("fw_regs", 0444, adev->debugfs_root, adev, &fw_regs_fops); |
| debugfs_create_file("debug_window", 0444, adev->debugfs_root, adev, &debug_window_fops); |
| |
| debugfs_create_u32("trace_aging_period", 0644, adev->debugfs_root, |
| &adev->aging_timer_period); |
| debugfs_create_u32("trace_fifo_full_period", 0644, adev->debugfs_root, |
| &adev->fifo_full_timer_period); |
| |
| debugfs_create_file("probe_points", 0644, adev->debugfs_root, adev, &probe_points_fops); |
| debugfs_create_file("probe_points_disconnect", 0200, adev->debugfs_root, adev, |
| &probe_points_disconnect_fops); |
| } |
| |
| void avs_debugfs_exit(struct avs_dev *adev) |
| { |
| debugfs_remove_recursive(adev->debugfs_root); |
| } |