// SPDX-License-Identifier: GPL-2.0/* * Debugfs interface * * Copyright (C) 2020, Intel Corporation * Authors: Gil Fine <gil.fine@intel.com> * Mika Westerberg <mika.westerberg@linux.intel.com> */ #include <linux/debugfs.h>#include <linux/pm_runtime.h>#include <linux/uaccess.h> #include "tb.h" #define PORT_CAP_PCIE_LEN 1#define PORT_CAP_POWER_LEN 2#define PORT_CAP_LANE_LEN 3#define PORT_CAP_USB3_LEN 5#define PORT_CAP_DP_LEN 8#define PORT_CAP_TMU_LEN 8#define PORT_CAP_BASIC_LEN 9#define PORT_CAP_USB4_LEN 20 #define SWITCH_CAP_TMU_LEN 26#define SWITCH_CAP_BASIC_LEN 27 #define PATH_LEN 2 #define COUNTER_SET_LEN 3 #define DEBUGFS_ATTR(__space, __write) \static int __space ## _open(struct inode *inode, struct file *file) \{ \ return single_open(file, __space ## _show, inode->i_private); \} \ \static const struct file_operations __space ## _fops = { \ .owner = THIS_MODULE, \ .open = __space ## _open, \ .release = single_release, \ .read = seq_read, \ .write = __write, \ .llseek = seq_lseek, \} #define DEBUGFS_ATTR_RO(__space) \ DEBUGFS_ATTR(__space, NULL) #define DEBUGFS_ATTR_RW(__space) \ DEBUGFS_ATTR(__space, __space ## _write) static struct dentry *tb_debugfs_root; static void *validate_and_copy_from_user(const void __user *user_buf, size_t *count){ size_t nbytes; void *buf; if (!*count) return ERR_PTR(-EINVAL); if (!access_ok(user_buf, *count)) return ERR_PTR(-EFAULT); buf = (void *)get_zeroed_page(GFP_KERNEL); if (!buf) return ERR_PTR(-ENOMEM); nbytes = min_t(size_t, *count, PAGE_SIZE); if (copy_from_user(buf, user_buf, nbytes)) { free_page((unsigned long)buf); return ERR_PTR(-EFAULT); } *count = nbytes; return buf;} static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len, int long_fmt_len){ char *token; u32 v[5]; int ret; token = strsep(line, "\n"); if (!token) return false; /* * For Adapter/Router configuration space: * Short format is: offset value\n * v[0] v[1] * Long format as produced from the read side: * offset relative_offset cap_id vs_cap_id value\n * v[0] v[1] v[2] v[3] v[4] * * For Counter configuration space: * Short format is: offset\n * v[0] * Long format as produced from the read side: * offset relative_offset counter_id value\n * v[0] v[1] v[2] v[3] */ ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]); /* In case of Counters, clear counter, "val" content is NA */ if (ret == short_fmt_len) { *offs = v[0]; *val = v[short_fmt_len - 1]; return true; } else if (ret == long_fmt_len) { *offs = v[0]; *val = v[long_fmt_len - 1]; return true; } return false;} #if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE)static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port, const char __user *user_buf, size_t count, loff_t *ppos){ struct tb *tb = sw->tb; char *line, *buf; u32 val, offset; int ret = 0; buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf); pm_runtime_get_sync(&sw->dev); if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; } /* User did hardware changes behind the driver's back */ add_taint(TAINT_USER, LOCKDEP_STILL_OK); line = buf; while (parse_line(&line, &offset, &val, 2, 5)) { if (port) ret = tb_port_write(port, &val, TB_CFG_PORT, offset, 1); else ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1); if (ret) break; } mutex_unlock(&tb->lock); out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf); return ret < 0 ? ret : count;} static ssize_t port_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private; return regs_write(port->sw, port, user_buf, count, ppos);} static ssize_t switch_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_switch *sw = s->private; return regs_write(sw, NULL, user_buf, count, ppos);}#define DEBUGFS_MODE 0600#else#define port_regs_write NULL#define switch_regs_write NULL#define DEBUGFS_MODE 0400#endif static int port_clear_all_counters(struct tb_port *port){ u32 *buf; int ret; buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32), GFP_KERNEL); if (!buf) return -ENOMEM; ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0, COUNTER_SET_LEN * port->config.max_counters); kfree(buf); return ret;} static ssize_t counters_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = port->sw->tb; char *buf; int ret; buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf); pm_runtime_get_sync(&sw->dev); if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; } /* If written delimiter only, clear all counters in one shot */ if (buf[0] == '\n') { ret = port_clear_all_counters(port); } else { char *line = buf; u32 val, offset; ret = -EINVAL; while (parse_line(&line, &offset, &val, 1, 4)) { ret = tb_port_write(port, &val, TB_CFG_COUNTERS, offset, 1); if (ret) break; } } mutex_unlock(&tb->lock); out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf); return ret < 0 ? ret : count;} static void cap_show_by_dw(struct seq_file *s, struct tb_switch *sw, struct tb_port *port, unsigned int cap, unsigned int offset, u8 cap_id, u8 vsec_id, int dwords){ int i, ret; u32 data; for (i = 0; i < dwords; i++) { if (port) ret = tb_port_read(port, &data, TB_CFG_PORT, cap + offset + i, 1); else ret = tb_sw_read(sw, &data, TB_CFG_SWITCH, cap + offset + i, 1); if (ret) { seq_printf(s, "0x%04x <not accessible>\n", cap + offset + i); continue; } seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i, offset + i, cap_id, vsec_id, data); }} static void cap_show(struct seq_file *s, struct tb_switch *sw, struct tb_port *port, unsigned int cap, u8 cap_id, u8 vsec_id, int length){ int ret, offset = 0; while (length > 0) { int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH); u32 data[TB_MAX_CONFIG_RW_LENGTH]; if (port) ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset, dwords); else ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords); if (ret) { cap_show_by_dw(s, sw, port, cap, offset, cap_id, vsec_id, length); return; } for (i = 0; i < dwords; i++) { seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i, offset + i, cap_id, vsec_id, data[i]); } length -= dwords; offset += dwords; }} static void port_cap_show(struct tb_port *port, struct seq_file *s, unsigned int cap){ struct tb_cap_any header; u8 vsec_id = 0; size_t length; int ret; ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap); return; } switch (header.basic.cap) { case TB_PORT_CAP_PHY: length = PORT_CAP_LANE_LEN; break; case TB_PORT_CAP_TIME1: length = PORT_CAP_TMU_LEN; break; case TB_PORT_CAP_POWER: length = PORT_CAP_POWER_LEN; break; case TB_PORT_CAP_ADAP: if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) { length = PORT_CAP_PCIE_LEN; } else if (tb_port_is_dpin(port) || tb_port_is_dpout(port)) { length = PORT_CAP_DP_LEN; } else if (tb_port_is_usb3_down(port) || tb_port_is_usb3_up(port)) { length = PORT_CAP_USB3_LEN; } else { seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n", cap, header.basic.cap); return; } break; case TB_PORT_CAP_VSE: if (!header.extended_short.length) { ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT, cap + 1, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap + 1); return; } length = header.extended_long.length; vsec_id = header.extended_short.vsec_id; } else { length = header.extended_short.length; vsec_id = header.extended_short.vsec_id; } break; case TB_PORT_CAP_USB4: length = PORT_CAP_USB4_LEN; break; default: seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n", cap, header.basic.cap); return; } cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length);} static void port_caps_show(struct tb_port *port, struct seq_file *s){ int cap; cap = tb_port_next_cap(port, 0); while (cap > 0) { port_cap_show(port, s, cap); cap = tb_port_next_cap(port, cap); }} static int port_basic_regs_show(struct tb_port *port, struct seq_file *s){ u32 data[PORT_CAP_BASIC_LEN]; int ret, i; ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data)); if (ret) return ret; for (i = 0; i < ARRAY_SIZE(data); i++) seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]); return 0;} static int port_regs_show(struct seq_file *s, void *not_used){ struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; int ret; pm_runtime_get_sync(&sw->dev); if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; } seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n"); ret = port_basic_regs_show(port, s); if (ret) goto out_unlock; port_caps_show(port, s); out_unlock: mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); return ret;}DEBUGFS_ATTR_RW(port_regs); static void switch_cap_show(struct tb_switch *sw, struct seq_file *s, unsigned int cap){ struct tb_cap_any header; int ret, length; u8 vsec_id = 0; ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap); return; } if (header.basic.cap == TB_SWITCH_CAP_VSE) { if (!header.extended_short.length) { ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH, cap + 1, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap + 1); return; } length = header.extended_long.length; } else { length = header.extended_short.length; } vsec_id = header.extended_short.vsec_id; } else { if (header.basic.cap == TB_SWITCH_CAP_TMU) { length = SWITCH_CAP_TMU_LEN; } else { seq_printf(s, "0x%04x <unknown capability 0x%02x>\n", cap, header.basic.cap); return; } } cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length);} static void switch_caps_show(struct tb_switch *sw, struct seq_file *s){ int cap; cap = tb_switch_next_cap(sw, 0); while (cap > 0) { switch_cap_show(sw, s, cap); cap = tb_switch_next_cap(sw, cap); }} static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s){ u32 data[SWITCH_CAP_BASIC_LEN]; size_t dwords; int ret, i; /* Only USB4 has the additional registers */ if (tb_switch_is_usb4(sw)) dwords = ARRAY_SIZE(data); else dwords = 7; Lines 1–500 of 737. Load more
// SPDX-License-Identifier: GPL-2.0 /* * Debugfs interface * * Copyright (C) 2020, Intel Corporation * Authors: Gil Fine <gil.fine@intel.com> * Mika Westerberg <mika.westerberg@linux.intel.com> */ #include <linux/debugfs.h> #include <linux/pm_runtime.h> #include <linux/uaccess.h> #include "tb.h" #define PORT_CAP_PCIE_LEN 1 #define PORT_CAP_POWER_LEN 2 #define PORT_CAP_LANE_LEN 3 #define PORT_CAP_USB3_LEN 5 #define PORT_CAP_DP_LEN 8 #define PORT_CAP_TMU_LEN 8 #define PORT_CAP_BASIC_LEN 9 #define PORT_CAP_USB4_LEN 20 #define SWITCH_CAP_TMU_LEN 26 #define SWITCH_CAP_BASIC_LEN 27 #define PATH_LEN 2 #define COUNTER_SET_LEN 3 #define DEBUGFS_ATTR(__space, __write) \ static int __space ## _open(struct inode *inode, struct file *file) \ { \ return single_open(file, __space ## _show, inode->i_private); \ } \ \ static const struct file_operations __space ## _fops = { \ .owner = THIS_MODULE, \ .open = __space ## _open, \ .release = single_release, \ .read = seq_read, \ .write = __write, \ .llseek = seq_lseek, \ } #define DEBUGFS_ATTR_RO(__space) \ DEBUGFS_ATTR(__space, NULL) #define DEBUGFS_ATTR_RW(__space) \ DEBUGFS_ATTR(__space, __space ## _write) static struct dentry *tb_debugfs_root; static void *validate_and_copy_from_user(const void __user *user_buf, size_t *count) { size_t nbytes; void *buf; if (!*count) return ERR_PTR(-EINVAL); if (!access_ok(user_buf, *count)) return ERR_PTR(-EFAULT); buf = (void *)get_zeroed_page(GFP_KERNEL); if (!buf) return ERR_PTR(-ENOMEM); nbytes = min_t(size_t, *count, PAGE_SIZE); if (copy_from_user(buf, user_buf, nbytes)) { free_page((unsigned long)buf); return ERR_PTR(-EFAULT); } *count = nbytes; return buf; } static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len, int long_fmt_len) { char *token; u32 v[5]; int ret; token = strsep(line, "\n"); if (!token) return false; /* * For Adapter/Router configuration space: * Short format is: offset value\n * v[0] v[1] * Long format as produced from the read side: * offset relative_offset cap_id vs_cap_id value\n * v[0] v[1] v[2] v[3] v[4] * * For Counter configuration space: * Short format is: offset\n * v[0] * Long format as produced from the read side: * offset relative_offset counter_id value\n * v[0] v[1] v[2] v[3] */ ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]); /* In case of Counters, clear counter, "val" content is NA */ if (ret == short_fmt_len) { *offs = v[0]; *val = v[short_fmt_len - 1]; return true; } else if (ret == long_fmt_len) { *offs = v[0]; *val = v[long_fmt_len - 1]; return true; } return false; } #if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE) static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port, const char __user *user_buf, size_t count, loff_t *ppos) { struct tb *tb = sw->tb; char *line, *buf; u32 val, offset; int ret = 0; buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf); pm_runtime_get_sync(&sw->dev); if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; } /* User did hardware changes behind the driver's back */ add_taint(TAINT_USER, LOCKDEP_STILL_OK); line = buf; while (parse_line(&line, &offset, &val, 2, 5)) { if (port) ret = tb_port_write(port, &val, TB_CFG_PORT, offset, 1); else ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1); if (ret) break; } mutex_unlock(&tb->lock); out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf); return ret < 0 ? ret : count; } static ssize_t port_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct seq_file *s = file->private_data; struct tb_port *port = s->private; return regs_write(port->sw, port, user_buf, count, ppos); } static ssize_t switch_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct seq_file *s = file->private_data; struct tb_switch *sw = s->private; return regs_write(sw, NULL, user_buf, count, ppos); } #define DEBUGFS_MODE 0600 #else #define port_regs_write NULL #define switch_regs_write NULL #define DEBUGFS_MODE 0400 #endif static int port_clear_all_counters(struct tb_port *port) { u32 *buf; int ret; buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32), GFP_KERNEL); if (!buf) return -ENOMEM; ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0, COUNTER_SET_LEN * port->config.max_counters); kfree(buf); return ret; } static ssize_t counters_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct seq_file *s = file->private_data; struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = port->sw->tb; char *buf; int ret; buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf); pm_runtime_get_sync(&sw->dev); if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; } /* If written delimiter only, clear all counters in one shot */ if (buf[0] == '\n') { ret = port_clear_all_counters(port); } else { char *line = buf; u32 val, offset; ret = -EINVAL; while (parse_line(&line, &offset, &val, 1, 4)) { ret = tb_port_write(port, &val, TB_CFG_COUNTERS, offset, 1); if (ret) break; } } mutex_unlock(&tb->lock); out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf); return ret < 0 ? ret : count; } static void cap_show_by_dw(struct seq_file *s, struct tb_switch *sw, struct tb_port *port, unsigned int cap, unsigned int offset, u8 cap_id, u8 vsec_id, int dwords) { int i, ret; u32 data; for (i = 0; i < dwords; i++) { if (port) ret = tb_port_read(port, &data, TB_CFG_PORT, cap + offset + i, 1); else ret = tb_sw_read(sw, &data, TB_CFG_SWITCH, cap + offset + i, 1); if (ret) { seq_printf(s, "0x%04x <not accessible>\n", cap + offset + i); continue; } seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i, offset + i, cap_id, vsec_id, data); } } static void cap_show(struct seq_file *s, struct tb_switch *sw, struct tb_port *port, unsigned int cap, u8 cap_id, u8 vsec_id, int length) { int ret, offset = 0; while (length > 0) { int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH); u32 data[TB_MAX_CONFIG_RW_LENGTH]; if (port) ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset, dwords); else ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords); if (ret) { cap_show_by_dw(s, sw, port, cap, offset, cap_id, vsec_id, length); return; } for (i = 0; i < dwords; i++) { seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i, offset + i, cap_id, vsec_id, data[i]); } length -= dwords; offset += dwords; } } static void port_cap_show(struct tb_port *port, struct seq_file *s, unsigned int cap) { struct tb_cap_any header; u8 vsec_id = 0; size_t length; int ret; ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap); return; } switch (header.basic.cap) { case TB_PORT_CAP_PHY: length = PORT_CAP_LANE_LEN; break; case TB_PORT_CAP_TIME1: length = PORT_CAP_TMU_LEN; break; case TB_PORT_CAP_POWER: length = PORT_CAP_POWER_LEN; break; case TB_PORT_CAP_ADAP: if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) { length = PORT_CAP_PCIE_LEN; } else if (tb_port_is_dpin(port) || tb_port_is_dpout(port)) { length = PORT_CAP_DP_LEN; } else if (tb_port_is_usb3_down(port) || tb_port_is_usb3_up(port)) { length = PORT_CAP_USB3_LEN; } else { seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n", cap, header.basic.cap); return; } break; case TB_PORT_CAP_VSE: if (!header.extended_short.length) { ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT, cap + 1, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap + 1); return; } length = header.extended_long.length; vsec_id = header.extended_short.vsec_id; } else { length = header.extended_short.length; vsec_id = header.extended_short.vsec_id; } break; case TB_PORT_CAP_USB4: length = PORT_CAP_USB4_LEN; break; default: seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n", cap, header.basic.cap); return; } cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length); } static void port_caps_show(struct tb_port *port, struct seq_file *s) { int cap; cap = tb_port_next_cap(port, 0); while (cap > 0) { port_cap_show(port, s, cap); cap = tb_port_next_cap(port, cap); } } static int port_basic_regs_show(struct tb_port *port, struct seq_file *s) { u32 data[PORT_CAP_BASIC_LEN]; int ret, i; ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data)); if (ret) return ret; for (i = 0; i < ARRAY_SIZE(data); i++) seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]); return 0; } static int port_regs_show(struct seq_file *s, void *not_used) { struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; int ret; pm_runtime_get_sync(&sw->dev); if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; } seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n"); ret = port_basic_regs_show(port, s); if (ret) goto out_unlock; port_caps_show(port, s); out_unlock: mutex_unlock(&tb->lock); out_rpm_put: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); return ret; } DEBUGFS_ATTR_RW(port_regs); static void switch_cap_show(struct tb_switch *sw, struct seq_file *s, unsigned int cap) { struct tb_cap_any header; int ret, length; u8 vsec_id = 0; ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap); return; } if (header.basic.cap == TB_SWITCH_CAP_VSE) { if (!header.extended_short.length) { ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH, cap + 1, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap + 1); return; } length = header.extended_long.length; } else { length = header.extended_short.length; } vsec_id = header.extended_short.vsec_id; } else { if (header.basic.cap == TB_SWITCH_CAP_TMU) { length = SWITCH_CAP_TMU_LEN; } else { seq_printf(s, "0x%04x <unknown capability 0x%02x>\n", cap, header.basic.cap); return; } } cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length); } static void switch_caps_show(struct tb_switch *sw, struct seq_file *s) { int cap; cap = tb_switch_next_cap(sw, 0); while (cap > 0) { switch_cap_show(sw, s, cap); cap = tb_switch_next_cap(sw, cap); } } static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s) { u32 data[SWITCH_CAP_BASIC_LEN]; size_t dwords; int ret, i; /* Only USB4 has the additional registers */ if (tb_switch_is_usb4(sw)) dwords = ARRAY_SIZE(data); else dwords = 7;