mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 18:41:23 +00:00
3382665a5c
Currently, when first failure occurs while reading of the block, we stop reading the block and jump to the next capability. This doesn't cover the case of block with "holes" of inaccessible dwords, followed by accessible dwords. This patch address this problem. In case of failure while reading the complete block in one transaction, (because of one or more dwords is inaccessible), we read the remaining dwords of the block dword-by-dword, one dword per transaction, till the end of the block. By doing this, we handle the case of block with "holes" of inaccessible dwords, followed by accessible dwords. The accessible dwords are shown with the fields: <offset> <relative_offset> <cap_id> <vs_cap_id> <value> E.g.: 0x01eb 236 0x05 0x06 0x0000d166 While the inaccesible dwords are shown as: <offset> <not accessible> E.g.: 0x01ed <not accessible> Signed-off-by: Gil Fine <gil.fine@intel.com> Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
738 lines
16 KiB
C
738 lines
16 KiB
C
// 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;
|
|
|
|
ret = tb_sw_read(sw, data, TB_CFG_SWITCH, 0, dwords);
|
|
if (ret)
|
|
return ret;
|
|
|
|
for (i = 0; i < dwords; i++)
|
|
seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int switch_regs_show(struct seq_file *s, void *not_used)
|
|
{
|
|
struct tb_switch *sw = s->private;
|
|
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 = switch_basic_regs_show(sw, s);
|
|
if (ret)
|
|
goto out_unlock;
|
|
|
|
switch_caps_show(sw, 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(switch_regs);
|
|
|
|
static int path_show_one(struct tb_port *port, struct seq_file *s, int hopid)
|
|
{
|
|
u32 data[PATH_LEN];
|
|
int ret, i;
|
|
|
|
ret = tb_port_read(port, data, TB_CFG_HOPS, hopid * PATH_LEN,
|
|
ARRAY_SIZE(data));
|
|
if (ret) {
|
|
seq_printf(s, "0x%04x <not accessible>\n", hopid * PATH_LEN);
|
|
return ret;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(data); i++) {
|
|
seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
|
|
hopid * PATH_LEN + i, i, hopid, data[i]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int path_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 start, i, ret = 0;
|
|
|
|
pm_runtime_get_sync(&sw->dev);
|
|
|
|
if (mutex_lock_interruptible(&tb->lock)) {
|
|
ret = -ERESTARTSYS;
|
|
goto out_rpm_put;
|
|
}
|
|
|
|
seq_puts(s, "# offset relative_offset in_hop_id value\n");
|
|
|
|
/* NHI and lane adapters have entry for path 0 */
|
|
if (tb_port_is_null(port) || tb_port_is_nhi(port)) {
|
|
ret = path_show_one(port, s, 0);
|
|
if (ret)
|
|
goto out_unlock;
|
|
}
|
|
|
|
start = tb_port_is_nhi(port) ? 1 : TB_PATH_MIN_HOPID;
|
|
|
|
for (i = start; i <= port->config.max_in_hop_id; i++) {
|
|
ret = path_show_one(port, s, i);
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
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_RO(path);
|
|
|
|
static int counter_set_regs_show(struct tb_port *port, struct seq_file *s,
|
|
int counter)
|
|
{
|
|
u32 data[COUNTER_SET_LEN];
|
|
int ret, i;
|
|
|
|
ret = tb_port_read(port, data, TB_CFG_COUNTERS,
|
|
counter * COUNTER_SET_LEN, ARRAY_SIZE(data));
|
|
if (ret) {
|
|
seq_printf(s, "0x%04x <not accessible>\n",
|
|
counter * COUNTER_SET_LEN);
|
|
return ret;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(data); i++) {
|
|
seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n",
|
|
counter * COUNTER_SET_LEN + i, i, counter, data[i]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int counters_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 i, ret = 0;
|
|
|
|
pm_runtime_get_sync(&sw->dev);
|
|
|
|
if (mutex_lock_interruptible(&tb->lock)) {
|
|
ret = -ERESTARTSYS;
|
|
goto out;
|
|
}
|
|
|
|
seq_puts(s, "# offset relative_offset counter_id value\n");
|
|
|
|
for (i = 0; i < port->config.max_counters; i++) {
|
|
ret = counter_set_regs_show(port, s, i);
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
out:
|
|
pm_runtime_mark_last_busy(&sw->dev);
|
|
pm_runtime_put_autosuspend(&sw->dev);
|
|
|
|
return ret;
|
|
}
|
|
DEBUGFS_ATTR_RW(counters);
|
|
|
|
/**
|
|
* tb_switch_debugfs_init() - Add debugfs entries for router
|
|
* @sw: Pointer to the router
|
|
*
|
|
* Adds debugfs directories and files for given router.
|
|
*/
|
|
void tb_switch_debugfs_init(struct tb_switch *sw)
|
|
{
|
|
struct dentry *debugfs_dir;
|
|
struct tb_port *port;
|
|
|
|
debugfs_dir = debugfs_create_dir(dev_name(&sw->dev), tb_debugfs_root);
|
|
sw->debugfs_dir = debugfs_dir;
|
|
debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, sw,
|
|
&switch_regs_fops);
|
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
struct dentry *debugfs_dir;
|
|
char dir_name[10];
|
|
|
|
if (port->disabled)
|
|
continue;
|
|
if (port->config.type == TB_TYPE_INACTIVE)
|
|
continue;
|
|
|
|
snprintf(dir_name, sizeof(dir_name), "port%d", port->port);
|
|
debugfs_dir = debugfs_create_dir(dir_name, sw->debugfs_dir);
|
|
debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir,
|
|
port, &port_regs_fops);
|
|
debugfs_create_file("path", 0400, debugfs_dir, port,
|
|
&path_fops);
|
|
if (port->config.counters_support)
|
|
debugfs_create_file("counters", 0600, debugfs_dir, port,
|
|
&counters_fops);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* tb_switch_debugfs_remove() - Remove all router debugfs entries
|
|
* @sw: Pointer to the router
|
|
*
|
|
* Removes all previously added debugfs entries under this router.
|
|
*/
|
|
void tb_switch_debugfs_remove(struct tb_switch *sw)
|
|
{
|
|
debugfs_remove_recursive(sw->debugfs_dir);
|
|
}
|
|
|
|
/**
|
|
* tb_service_debugfs_init() - Add debugfs directory for service
|
|
* @svc: Thunderbolt service pointer
|
|
*
|
|
* Adds debugfs directory for service.
|
|
*/
|
|
void tb_service_debugfs_init(struct tb_service *svc)
|
|
{
|
|
svc->debugfs_dir = debugfs_create_dir(dev_name(&svc->dev),
|
|
tb_debugfs_root);
|
|
}
|
|
|
|
/**
|
|
* tb_service_debugfs_remove() - Remove service debugfs directory
|
|
* @svc: Thunderbolt service pointer
|
|
*
|
|
* Removes the previously created debugfs directory for @svc.
|
|
*/
|
|
void tb_service_debugfs_remove(struct tb_service *svc)
|
|
{
|
|
debugfs_remove_recursive(svc->debugfs_dir);
|
|
svc->debugfs_dir = NULL;
|
|
}
|
|
|
|
void tb_debugfs_init(void)
|
|
{
|
|
tb_debugfs_root = debugfs_create_dir("thunderbolt", NULL);
|
|
}
|
|
|
|
void tb_debugfs_exit(void)
|
|
{
|
|
debugfs_remove_recursive(tb_debugfs_root);
|
|
}
|