diff options
Diffstat (limited to 'drivers/usb/dwc3/debugfs.c')
| -rw-r--r-- | drivers/usb/dwc3/debugfs.c | 428 |
1 files changed, 428 insertions, 0 deletions
diff --git a/drivers/usb/dwc3/debugfs.c b/drivers/usb/dwc3/debugfs.c index 9ac37fe1b6a7..703652a4e267 100644 --- a/drivers/usb/dwc3/debugfs.c +++ b/drivers/usb/dwc3/debugfs.c @@ -16,6 +16,7 @@ * GNU General Public License for more details. */ +#include <linux/module.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/ptrace.h> @@ -618,6 +619,406 @@ static const struct file_operations dwc3_link_state_fops = { .release = single_release, }; +static int ep_num; +static ssize_t dwc3_store_ep_num(struct file *file, const char __user *ubuf, + size_t count, loff_t *ppos) +{ + struct seq_file *s = file->private_data; + struct dwc3 *dwc = s->private; + char kbuf[10]; + unsigned int num, dir; + unsigned long flags; + + memset(kbuf, 0, 10); + + if (copy_from_user(kbuf, ubuf, count > 10 ? 10 : count)) + return -EFAULT; + + if (sscanf(kbuf, "%u %u", &num, &dir) != 2) + return -EINVAL; + + spin_lock_irqsave(&dwc->lock, flags); + ep_num = (num << 1) + dir; + spin_unlock_irqrestore(&dwc->lock, flags); + + return count; +} + +static int dwc3_ep_req_list_show(struct seq_file *s, void *unused) +{ + struct dwc3 *dwc = s->private; + struct dwc3_ep *dep; + struct dwc3_request *req = NULL; + struct list_head *ptr = NULL; + unsigned long flags; + + spin_lock_irqsave(&dwc->lock, flags); + dep = dwc->eps[ep_num]; + + seq_printf(s, "%s request list: flags: 0x%x\n", dep->name, dep->flags); + list_for_each(ptr, &dep->request_list) { + req = list_entry(ptr, struct dwc3_request, list); + + seq_printf(s, + "req:0x%p len: %d sts: %d dma:0x%pa num_sgs: %d\n", + req, req->request.length, req->request.status, + &req->request.dma, req->request.num_sgs); + } + spin_unlock_irqrestore(&dwc->lock, flags); + + return 0; +} + +static int dwc3_ep_req_list_open(struct inode *inode, struct file *file) +{ + return single_open(file, dwc3_ep_req_list_show, inode->i_private); +} + +static const struct file_operations dwc3_ep_req_list_fops = { + .open = dwc3_ep_req_list_open, + .write = dwc3_store_ep_num, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static int dwc3_ep_queued_req_show(struct seq_file *s, void *unused) +{ + struct dwc3 *dwc = s->private; + struct dwc3_ep *dep; + struct dwc3_request *req = NULL; + struct list_head *ptr = NULL; + unsigned long flags; + + spin_lock_irqsave(&dwc->lock, flags); + dep = dwc->eps[ep_num]; + + seq_printf(s, "%s queued reqs to HW: flags:0x%x\n", dep->name, + dep->flags); + list_for_each(ptr, &dep->req_queued) { + req = list_entry(ptr, struct dwc3_request, list); + + seq_printf(s, + "req:0x%p len:%d sts:%d dma:%pa nsg:%d trb:0x%p\n", + req, req->request.length, req->request.status, + &req->request.dma, req->request.num_sgs, req->trb); + } + spin_unlock_irqrestore(&dwc->lock, flags); + + return 0; +} + +static int dwc3_ep_queued_req_open(struct inode *inode, struct file *file) +{ + return single_open(file, dwc3_ep_queued_req_show, inode->i_private); +} + +const struct file_operations dwc3_ep_req_queued_fops = { + .open = dwc3_ep_queued_req_open, + .write = dwc3_store_ep_num, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static int dwc3_ep_trbs_show(struct seq_file *s, void *unused) +{ + struct dwc3 *dwc = s->private; + struct dwc3_ep *dep; + struct dwc3_trb *trb; + unsigned long flags; + int j; + + if (!ep_num) + return 0; + + spin_lock_irqsave(&dwc->lock, flags); + dep = dwc->eps[ep_num]; + + seq_printf(s, "%s trb pool: flags:0x%x freeslot:%d busyslot:%d\n", + dep->name, dep->flags, dep->free_slot, dep->busy_slot); + for (j = 0; j < DWC3_TRB_NUM; j++) { + trb = &dep->trb_pool[j]; + seq_printf(s, "trb:0x%p bph:0x%x bpl:0x%x size:0x%x ctrl: %x\n", + trb, trb->bph, trb->bpl, trb->size, trb->ctrl); + } + spin_unlock_irqrestore(&dwc->lock, flags); + + return 0; +} + +static int dwc3_ep_trbs_list_open(struct inode *inode, struct file *file) +{ + return single_open(file, dwc3_ep_trbs_show, inode->i_private); +} + +const struct file_operations dwc3_ep_trb_list_fops = { + .open = dwc3_ep_trbs_list_open, + .write = dwc3_store_ep_num, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static unsigned int ep_addr_rxdbg_mask = 1; +module_param(ep_addr_rxdbg_mask, uint, S_IRUGO | S_IWUSR); +static unsigned int ep_addr_txdbg_mask = 1; +module_param(ep_addr_txdbg_mask, uint, S_IRUGO | S_IWUSR); + +/* Maximum debug message length */ +#define DBG_DATA_MSG 64UL + +/* Maximum number of messages */ +#define DBG_DATA_MAX 2048UL + +static struct { + char (buf[DBG_DATA_MAX])[DBG_DATA_MSG]; /* buffer */ + unsigned idx; /* index */ + unsigned tty; /* print to console? */ + rwlock_t lck; /* lock */ +} dbg_dwc3_data = { + .idx = 0, + .tty = 0, + .lck = __RW_LOCK_UNLOCKED(lck) +}; + +/** + * dbg_dec: decrements debug event index + * @idx: buffer index + */ +static inline void __maybe_unused dbg_dec(unsigned *idx) +{ + *idx = (*idx - 1) % DBG_DATA_MAX; +} + +/** + * dbg_inc: increments debug event index + * @idx: buffer index + */ +static inline void dbg_inc(unsigned *idx) +{ + *idx = (*idx + 1) % DBG_DATA_MAX; +} + +#define TIME_BUF_LEN 20 +/*get_timestamp - returns time of day in us */ +static char *get_timestamp(char *tbuf) +{ + unsigned long long t; + unsigned long nanosec_rem; + + t = cpu_clock(smp_processor_id()); + nanosec_rem = do_div(t, 1000000000)/1000; + scnprintf(tbuf, TIME_BUF_LEN, "[%5lu.%06lu] ", (unsigned long)t, + nanosec_rem); + return tbuf; +} + +static int allow_dbg_print(u8 ep_num) +{ + int dir, num; + + /* allow bus wide events */ + if (ep_num == 0xff) + return 1; + + dir = ep_num & 0x1; + num = ep_num >> 1; + num = 1 << num; + + if (dir && (num & ep_addr_txdbg_mask)) + return 1; + if (!dir && (num & ep_addr_rxdbg_mask)) + return 1; + + return 0; +} + +/** + * dbg_print: prints the common part of the event + * @addr: endpoint address + * @name: event name + * @status: status + * @extra: extra information + */ +void dbg_print(u8 ep_num, const char *name, int status, const char *extra) +{ + unsigned long flags; + char tbuf[TIME_BUF_LEN]; + + if (!allow_dbg_print(ep_num)) + return; + + write_lock_irqsave(&dbg_dwc3_data.lck, flags); + + scnprintf(dbg_dwc3_data.buf[dbg_dwc3_data.idx], DBG_DATA_MSG, + "%s\t? %02X %-12.12s %4i ?\t%s\n", + get_timestamp(tbuf), ep_num, name, status, extra); + + dbg_inc(&dbg_dwc3_data.idx); + + write_unlock_irqrestore(&dbg_dwc3_data.lck, flags); + + if (dbg_dwc3_data.tty != 0) + pr_notice("%s\t? %02X %-7.7s %4i ?\t%s\n", + get_timestamp(tbuf), ep_num, name, status, extra); +} + +/** + * dbg_done: prints a DONE event + * @addr: endpoint address + * @td: transfer descriptor + * @status: status + */ +void dbg_done(u8 ep_num, const u32 count, int status) +{ + char msg[DBG_DATA_MSG]; + + if (!allow_dbg_print(ep_num)) + return; + + scnprintf(msg, sizeof(msg), "%d", count); + dbg_print(ep_num, "DONE", status, msg); +} + +/** + * dbg_event: prints a generic event + * @addr: endpoint address + * @name: event name + * @status: status + */ +void dbg_event(u8 ep_num, const char *name, int status) +{ + if (!allow_dbg_print(ep_num)) + return; + + if (name != NULL) + dbg_print(ep_num, name, status, ""); +} + +/* + * dbg_queue: prints a QUEUE event + * @addr: endpoint address + * @req: USB request + * @status: status + */ +void dbg_queue(u8 ep_num, const struct usb_request *req, int status) +{ + char msg[DBG_DATA_MSG]; + + if (!allow_dbg_print(ep_num)) + return; + + if (req != NULL) { + scnprintf(msg, sizeof(msg), + "%d %d", !req->no_interrupt, req->length); + dbg_print(ep_num, "QUEUE", status, msg); + } +} + +/** + * dbg_setup: prints a SETUP event + * @addr: endpoint address + * @req: setup request + */ +void dbg_setup(u8 ep_num, const struct usb_ctrlrequest *req) +{ + char msg[DBG_DATA_MSG]; + + if (!allow_dbg_print(ep_num)) + return; + + if (req != NULL) { + scnprintf(msg, sizeof(msg), + "%02X %02X %04X %04X %d", req->bRequestType, + req->bRequest, le16_to_cpu(req->wValue), + le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength)); + dbg_print(ep_num, "SETUP", 0, msg); + } +} + +/** + * dbg_print_reg: prints a reg value + * @name: reg name + * @reg: reg value to be printed + */ +void dbg_print_reg(const char *name, int reg) +{ + unsigned long flags; + + write_lock_irqsave(&dbg_dwc3_data.lck, flags); + + scnprintf(dbg_dwc3_data.buf[dbg_dwc3_data.idx], DBG_DATA_MSG, + "%s = 0x%08x\n", name, reg); + + dbg_inc(&dbg_dwc3_data.idx); + + write_unlock_irqrestore(&dbg_dwc3_data.lck, flags); + + if (dbg_dwc3_data.tty != 0) + pr_notice("%s = 0x%08x\n", name, reg); +} + +/** + * store_events: configure if events are going to be also printed to console + * + */ +static ssize_t dwc3_store_events(struct file *file, + const char __user *buf, size_t count, loff_t *ppos) +{ + unsigned tty; + + if (buf == NULL) { + pr_err("[%s] EINVAL\n", __func__); + goto done; + } + + if (sscanf(buf, "%u", &tty) != 1 || tty > 1) { + pr_err("<1|0>: enable|disable console log\n"); + goto done; + } + + dbg_dwc3_data.tty = tty; + pr_info("tty = %u", dbg_dwc3_data.tty); + + done: + return count; +} + +static int dwc3_gadget_data_events_show(struct seq_file *s, void *unused) +{ + unsigned long flags; + unsigned i; + + read_lock_irqsave(&dbg_dwc3_data.lck, flags); + + i = dbg_dwc3_data.idx; + if (strnlen(dbg_dwc3_data.buf[i], DBG_DATA_MSG)) + seq_printf(s, "%s\n", dbg_dwc3_data.buf[i]); + for (dbg_inc(&i); i != dbg_dwc3_data.idx; dbg_inc(&i)) { + if (!strnlen(dbg_dwc3_data.buf[i], DBG_DATA_MSG)) + continue; + seq_printf(s, "%s\n", dbg_dwc3_data.buf[i]); + } + + read_unlock_irqrestore(&dbg_dwc3_data.lck, flags); + + return 0; +} + +static int dwc3_gadget_data_events_open(struct inode *inode, struct file *f) +{ + return single_open(f, dwc3_gadget_data_events_show, inode->i_private); +} + +const struct file_operations dwc3_gadget_dbg_data_fops = { + .open = dwc3_gadget_data_events_open, + .read = seq_read, + .write = dwc3_store_events, + .llseek = seq_lseek, + .release = single_release, +}; + int dwc3_debugfs_init(struct dwc3 *dwc) { struct dentry *root; @@ -674,6 +1075,33 @@ int dwc3_debugfs_init(struct dwc3 *dwc) } } + file = debugfs_create_file("trbs", S_IRUGO | S_IWUSR, root, + dwc, &dwc3_ep_trb_list_fops); + if (!file) { + ret = -ENOMEM; + goto err1; + } + + file = debugfs_create_file("requests", S_IRUGO | S_IWUSR, root, + dwc, &dwc3_ep_req_list_fops); + if (!file) { + ret = -ENOMEM; + goto err1; + } + + file = debugfs_create_file("queued_reqs", S_IRUGO | S_IWUSR, root, + dwc, &dwc3_ep_req_queued_fops); + if (!file) { + ret = -ENOMEM; + goto err1; + } + + file = debugfs_create_file("events", S_IRUGO | S_IWUSR, root, + dwc, &dwc3_gadget_dbg_data_fops); + if (!file) { + ret = -ENOMEM; + goto err1; + } return 0; err1: |