mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
766 lines
15 KiB
766 lines
15 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. |
|
*/ |
|
#include <linux/debugfs.h> |
|
#include <linux/dma-mapping.h> |
|
#include <linux/slab.h> |
|
#include <linux/uaccess.h> |
|
|
|
#include <soc/tegra/bpmp.h> |
|
#include <soc/tegra/bpmp-abi.h> |
|
|
|
static DEFINE_MUTEX(bpmp_debug_lock); |
|
|
|
struct seqbuf { |
|
char *buf; |
|
size_t pos; |
|
size_t size; |
|
}; |
|
|
|
static void seqbuf_init(struct seqbuf *seqbuf, void *buf, size_t size) |
|
{ |
|
seqbuf->buf = buf; |
|
seqbuf->size = size; |
|
seqbuf->pos = 0; |
|
} |
|
|
|
static size_t seqbuf_avail(struct seqbuf *seqbuf) |
|
{ |
|
return seqbuf->pos < seqbuf->size ? seqbuf->size - seqbuf->pos : 0; |
|
} |
|
|
|
static size_t seqbuf_status(struct seqbuf *seqbuf) |
|
{ |
|
return seqbuf->pos <= seqbuf->size ? 0 : -EOVERFLOW; |
|
} |
|
|
|
static int seqbuf_eof(struct seqbuf *seqbuf) |
|
{ |
|
return seqbuf->pos >= seqbuf->size; |
|
} |
|
|
|
static int seqbuf_read(struct seqbuf *seqbuf, void *buf, size_t nbyte) |
|
{ |
|
nbyte = min(nbyte, seqbuf_avail(seqbuf)); |
|
memcpy(buf, seqbuf->buf + seqbuf->pos, nbyte); |
|
seqbuf->pos += nbyte; |
|
return seqbuf_status(seqbuf); |
|
} |
|
|
|
static int seqbuf_read_u32(struct seqbuf *seqbuf, uint32_t *v) |
|
{ |
|
int err; |
|
|
|
err = seqbuf_read(seqbuf, v, 4); |
|
*v = le32_to_cpu(*v); |
|
return err; |
|
} |
|
|
|
static int seqbuf_read_str(struct seqbuf *seqbuf, const char **str) |
|
{ |
|
*str = seqbuf->buf + seqbuf->pos; |
|
seqbuf->pos += strnlen(*str, seqbuf_avail(seqbuf)); |
|
seqbuf->pos++; |
|
return seqbuf_status(seqbuf); |
|
} |
|
|
|
static void seqbuf_seek(struct seqbuf *seqbuf, ssize_t offset) |
|
{ |
|
seqbuf->pos += offset; |
|
} |
|
|
|
/* map filename in Linux debugfs to corresponding entry in BPMP */ |
|
static const char *get_filename(struct tegra_bpmp *bpmp, |
|
const struct file *file, char *buf, int size) |
|
{ |
|
char root_path_buf[512]; |
|
const char *root_path; |
|
const char *filename; |
|
size_t root_len; |
|
|
|
root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf, |
|
sizeof(root_path_buf)); |
|
if (IS_ERR(root_path)) |
|
return NULL; |
|
|
|
root_len = strlen(root_path); |
|
|
|
filename = dentry_path(file->f_path.dentry, buf, size); |
|
if (IS_ERR(filename)) |
|
return NULL; |
|
|
|
if (strlen(filename) < root_len || |
|
strncmp(filename, root_path, root_len)) |
|
return NULL; |
|
|
|
filename += root_len; |
|
|
|
return filename; |
|
} |
|
|
|
static int mrq_debug_open(struct tegra_bpmp *bpmp, const char *name, |
|
uint32_t *fd, uint32_t *len, bool write) |
|
{ |
|
struct mrq_debug_request req = { |
|
.cmd = cpu_to_le32(write ? CMD_DEBUG_OPEN_WO : CMD_DEBUG_OPEN_RO), |
|
}; |
|
struct mrq_debug_response resp; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUG, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
.rx = { |
|
.data = &resp, |
|
.size = sizeof(resp), |
|
}, |
|
}; |
|
ssize_t sz_name; |
|
int err = 0; |
|
|
|
sz_name = strscpy(req.fop.name, name, sizeof(req.fop.name)); |
|
if (sz_name < 0) { |
|
pr_err("File name too large: %s\n", name); |
|
return -EINVAL; |
|
} |
|
|
|
err = tegra_bpmp_transfer(bpmp, &msg); |
|
if (err < 0) |
|
return err; |
|
else if (msg.rx.ret < 0) |
|
return -EINVAL; |
|
|
|
*len = resp.fop.datalen; |
|
*fd = resp.fop.fd; |
|
|
|
return 0; |
|
} |
|
|
|
static int mrq_debug_close(struct tegra_bpmp *bpmp, uint32_t fd) |
|
{ |
|
struct mrq_debug_request req = { |
|
.cmd = cpu_to_le32(CMD_DEBUG_CLOSE), |
|
.frd = { |
|
.fd = fd, |
|
}, |
|
}; |
|
struct mrq_debug_response resp; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUG, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
.rx = { |
|
.data = &resp, |
|
.size = sizeof(resp), |
|
}, |
|
}; |
|
int err = 0; |
|
|
|
err = tegra_bpmp_transfer(bpmp, &msg); |
|
if (err < 0) |
|
return err; |
|
else if (msg.rx.ret < 0) |
|
return -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static int mrq_debug_read(struct tegra_bpmp *bpmp, const char *name, |
|
char *data, size_t sz_data, uint32_t *nbytes) |
|
{ |
|
struct mrq_debug_request req = { |
|
.cmd = cpu_to_le32(CMD_DEBUG_READ), |
|
}; |
|
struct mrq_debug_response resp; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUG, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
.rx = { |
|
.data = &resp, |
|
.size = sizeof(resp), |
|
}, |
|
}; |
|
uint32_t fd = 0, len = 0; |
|
int remaining, err; |
|
|
|
mutex_lock(&bpmp_debug_lock); |
|
err = mrq_debug_open(bpmp, name, &fd, &len, 0); |
|
if (err) |
|
goto out; |
|
|
|
if (len > sz_data) { |
|
err = -EFBIG; |
|
goto close; |
|
} |
|
|
|
req.frd.fd = fd; |
|
remaining = len; |
|
|
|
while (remaining > 0) { |
|
err = tegra_bpmp_transfer(bpmp, &msg); |
|
if (err < 0) { |
|
goto close; |
|
} else if (msg.rx.ret < 0) { |
|
err = -EINVAL; |
|
goto close; |
|
} |
|
|
|
if (resp.frd.readlen > remaining) { |
|
pr_err("%s: read data length invalid\n", __func__); |
|
err = -EINVAL; |
|
goto close; |
|
} |
|
|
|
memcpy(data, resp.frd.data, resp.frd.readlen); |
|
data += resp.frd.readlen; |
|
remaining -= resp.frd.readlen; |
|
} |
|
|
|
*nbytes = len; |
|
|
|
close: |
|
err = mrq_debug_close(bpmp, fd); |
|
out: |
|
mutex_unlock(&bpmp_debug_lock); |
|
return err; |
|
} |
|
|
|
static int mrq_debug_write(struct tegra_bpmp *bpmp, const char *name, |
|
uint8_t *data, size_t sz_data) |
|
{ |
|
struct mrq_debug_request req = { |
|
.cmd = cpu_to_le32(CMD_DEBUG_WRITE) |
|
}; |
|
struct mrq_debug_response resp; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUG, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
.rx = { |
|
.data = &resp, |
|
.size = sizeof(resp), |
|
}, |
|
}; |
|
uint32_t fd = 0, len = 0; |
|
size_t remaining; |
|
int err; |
|
|
|
mutex_lock(&bpmp_debug_lock); |
|
err = mrq_debug_open(bpmp, name, &fd, &len, 1); |
|
if (err) |
|
goto out; |
|
|
|
if (sz_data > len) { |
|
err = -EINVAL; |
|
goto close; |
|
} |
|
|
|
req.fwr.fd = fd; |
|
remaining = sz_data; |
|
|
|
while (remaining > 0) { |
|
len = min(remaining, sizeof(req.fwr.data)); |
|
memcpy(req.fwr.data, data, len); |
|
req.fwr.datalen = len; |
|
|
|
err = tegra_bpmp_transfer(bpmp, &msg); |
|
if (err < 0) { |
|
goto close; |
|
} else if (msg.rx.ret < 0) { |
|
err = -EINVAL; |
|
goto close; |
|
} |
|
|
|
data += req.fwr.datalen; |
|
remaining -= req.fwr.datalen; |
|
} |
|
|
|
close: |
|
err = mrq_debug_close(bpmp, fd); |
|
out: |
|
mutex_unlock(&bpmp_debug_lock); |
|
return err; |
|
} |
|
|
|
static int bpmp_debug_show(struct seq_file *m, void *p) |
|
{ |
|
struct file *file = m->private; |
|
struct inode *inode = file_inode(file); |
|
struct tegra_bpmp *bpmp = inode->i_private; |
|
char *databuf = NULL; |
|
char fnamebuf[256]; |
|
const char *filename; |
|
uint32_t nbytes = 0; |
|
size_t len; |
|
int err; |
|
|
|
len = seq_get_buf(m, &databuf); |
|
if (!databuf) |
|
return -ENOMEM; |
|
|
|
filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf)); |
|
if (!filename) |
|
return -ENOENT; |
|
|
|
err = mrq_debug_read(bpmp, filename, databuf, len, &nbytes); |
|
if (!err) |
|
seq_commit(m, nbytes); |
|
|
|
return err; |
|
} |
|
|
|
static ssize_t bpmp_debug_store(struct file *file, const char __user *buf, |
|
size_t count, loff_t *f_pos) |
|
{ |
|
struct inode *inode = file_inode(file); |
|
struct tegra_bpmp *bpmp = inode->i_private; |
|
char *databuf = NULL; |
|
char fnamebuf[256]; |
|
const char *filename; |
|
ssize_t err; |
|
|
|
filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf)); |
|
if (!filename) |
|
return -ENOENT; |
|
|
|
databuf = kmalloc(count, GFP_KERNEL); |
|
if (!databuf) |
|
return -ENOMEM; |
|
|
|
if (copy_from_user(databuf, buf, count)) { |
|
err = -EFAULT; |
|
goto free_ret; |
|
} |
|
|
|
err = mrq_debug_write(bpmp, filename, databuf, count); |
|
|
|
free_ret: |
|
kfree(databuf); |
|
|
|
return err ?: count; |
|
} |
|
|
|
static int bpmp_debug_open(struct inode *inode, struct file *file) |
|
{ |
|
return single_open_size(file, bpmp_debug_show, file, SZ_256K); |
|
} |
|
|
|
static const struct file_operations bpmp_debug_fops = { |
|
.open = bpmp_debug_open, |
|
.read = seq_read, |
|
.llseek = seq_lseek, |
|
.write = bpmp_debug_store, |
|
.release = single_release, |
|
}; |
|
|
|
static int bpmp_populate_debugfs_inband(struct tegra_bpmp *bpmp, |
|
struct dentry *parent, |
|
char *ppath) |
|
{ |
|
const size_t pathlen = SZ_256; |
|
const size_t bufsize = SZ_16K; |
|
uint32_t dsize, attrs = 0; |
|
struct dentry *dentry; |
|
struct seqbuf seqbuf; |
|
char *buf, *pathbuf; |
|
const char *name; |
|
int err = 0; |
|
|
|
if (!bpmp || !parent || !ppath) |
|
return -EINVAL; |
|
|
|
buf = kmalloc(bufsize, GFP_KERNEL); |
|
if (!buf) |
|
return -ENOMEM; |
|
|
|
pathbuf = kzalloc(pathlen, GFP_KERNEL); |
|
if (!pathbuf) { |
|
kfree(buf); |
|
return -ENOMEM; |
|
} |
|
|
|
err = mrq_debug_read(bpmp, ppath, buf, bufsize, &dsize); |
|
if (err) |
|
goto out; |
|
|
|
seqbuf_init(&seqbuf, buf, dsize); |
|
|
|
while (!seqbuf_eof(&seqbuf)) { |
|
err = seqbuf_read_u32(&seqbuf, &attrs); |
|
if (err) |
|
goto out; |
|
|
|
err = seqbuf_read_str(&seqbuf, &name); |
|
if (err < 0) |
|
goto out; |
|
|
|
if (attrs & DEBUGFS_S_ISDIR) { |
|
size_t len; |
|
|
|
dentry = debugfs_create_dir(name, parent); |
|
if (IS_ERR(dentry)) { |
|
err = PTR_ERR(dentry); |
|
goto out; |
|
} |
|
|
|
len = snprintf(pathbuf, pathlen, "%s%s/", ppath, name); |
|
if (len >= pathlen) { |
|
err = -EINVAL; |
|
goto out; |
|
} |
|
|
|
err = bpmp_populate_debugfs_inband(bpmp, dentry, |
|
pathbuf); |
|
if (err < 0) |
|
goto out; |
|
} else { |
|
umode_t mode; |
|
|
|
mode = attrs & DEBUGFS_S_IRUSR ? 0400 : 0; |
|
mode |= attrs & DEBUGFS_S_IWUSR ? 0200 : 0; |
|
dentry = debugfs_create_file(name, mode, parent, bpmp, |
|
&bpmp_debug_fops); |
|
if (!dentry) { |
|
err = -ENOMEM; |
|
goto out; |
|
} |
|
} |
|
} |
|
|
|
out: |
|
kfree(pathbuf); |
|
kfree(buf); |
|
|
|
return err; |
|
} |
|
|
|
static int mrq_debugfs_read(struct tegra_bpmp *bpmp, |
|
dma_addr_t name, size_t sz_name, |
|
dma_addr_t data, size_t sz_data, |
|
size_t *nbytes) |
|
{ |
|
struct mrq_debugfs_request req = { |
|
.cmd = cpu_to_le32(CMD_DEBUGFS_READ), |
|
.fop = { |
|
.fnameaddr = cpu_to_le32((uint32_t)name), |
|
.fnamelen = cpu_to_le32((uint32_t)sz_name), |
|
.dataaddr = cpu_to_le32((uint32_t)data), |
|
.datalen = cpu_to_le32((uint32_t)sz_data), |
|
}, |
|
}; |
|
struct mrq_debugfs_response resp; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUGFS, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
.rx = { |
|
.data = &resp, |
|
.size = sizeof(resp), |
|
}, |
|
}; |
|
int err; |
|
|
|
err = tegra_bpmp_transfer(bpmp, &msg); |
|
if (err < 0) |
|
return err; |
|
else if (msg.rx.ret < 0) |
|
return -EINVAL; |
|
|
|
*nbytes = (size_t)resp.fop.nbytes; |
|
|
|
return 0; |
|
} |
|
|
|
static int mrq_debugfs_write(struct tegra_bpmp *bpmp, |
|
dma_addr_t name, size_t sz_name, |
|
dma_addr_t data, size_t sz_data) |
|
{ |
|
const struct mrq_debugfs_request req = { |
|
.cmd = cpu_to_le32(CMD_DEBUGFS_WRITE), |
|
.fop = { |
|
.fnameaddr = cpu_to_le32((uint32_t)name), |
|
.fnamelen = cpu_to_le32((uint32_t)sz_name), |
|
.dataaddr = cpu_to_le32((uint32_t)data), |
|
.datalen = cpu_to_le32((uint32_t)sz_data), |
|
}, |
|
}; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUGFS, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
}; |
|
|
|
return tegra_bpmp_transfer(bpmp, &msg); |
|
} |
|
|
|
static int mrq_debugfs_dumpdir(struct tegra_bpmp *bpmp, dma_addr_t addr, |
|
size_t size, size_t *nbytes) |
|
{ |
|
const struct mrq_debugfs_request req = { |
|
.cmd = cpu_to_le32(CMD_DEBUGFS_DUMPDIR), |
|
.dumpdir = { |
|
.dataaddr = cpu_to_le32((uint32_t)addr), |
|
.datalen = cpu_to_le32((uint32_t)size), |
|
}, |
|
}; |
|
struct mrq_debugfs_response resp; |
|
struct tegra_bpmp_message msg = { |
|
.mrq = MRQ_DEBUGFS, |
|
.tx = { |
|
.data = &req, |
|
.size = sizeof(req), |
|
}, |
|
.rx = { |
|
.data = &resp, |
|
.size = sizeof(resp), |
|
}, |
|
}; |
|
int err; |
|
|
|
err = tegra_bpmp_transfer(bpmp, &msg); |
|
if (err < 0) |
|
return err; |
|
else if (msg.rx.ret < 0) |
|
return -EINVAL; |
|
|
|
*nbytes = (size_t)resp.dumpdir.nbytes; |
|
|
|
return 0; |
|
} |
|
|
|
static int debugfs_show(struct seq_file *m, void *p) |
|
{ |
|
struct file *file = m->private; |
|
struct inode *inode = file_inode(file); |
|
struct tegra_bpmp *bpmp = inode->i_private; |
|
const size_t datasize = m->size; |
|
const size_t namesize = SZ_256; |
|
void *datavirt, *namevirt; |
|
dma_addr_t dataphys, namephys; |
|
char buf[256]; |
|
const char *filename; |
|
size_t len, nbytes; |
|
int err; |
|
|
|
filename = get_filename(bpmp, file, buf, sizeof(buf)); |
|
if (!filename) |
|
return -ENOENT; |
|
|
|
namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys, |
|
GFP_KERNEL | GFP_DMA32); |
|
if (!namevirt) |
|
return -ENOMEM; |
|
|
|
datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys, |
|
GFP_KERNEL | GFP_DMA32); |
|
if (!datavirt) { |
|
err = -ENOMEM; |
|
goto free_namebuf; |
|
} |
|
|
|
len = strlen(filename); |
|
strncpy(namevirt, filename, namesize); |
|
|
|
err = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize, |
|
&nbytes); |
|
|
|
if (!err) |
|
seq_write(m, datavirt, nbytes); |
|
|
|
dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys); |
|
free_namebuf: |
|
dma_free_coherent(bpmp->dev, namesize, namevirt, namephys); |
|
|
|
return err; |
|
} |
|
|
|
static int debugfs_open(struct inode *inode, struct file *file) |
|
{ |
|
return single_open_size(file, debugfs_show, file, SZ_128K); |
|
} |
|
|
|
static ssize_t debugfs_store(struct file *file, const char __user *buf, |
|
size_t count, loff_t *f_pos) |
|
{ |
|
struct inode *inode = file_inode(file); |
|
struct tegra_bpmp *bpmp = inode->i_private; |
|
const size_t datasize = count; |
|
const size_t namesize = SZ_256; |
|
void *datavirt, *namevirt; |
|
dma_addr_t dataphys, namephys; |
|
char fnamebuf[256]; |
|
const char *filename; |
|
size_t len; |
|
int err; |
|
|
|
filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf)); |
|
if (!filename) |
|
return -ENOENT; |
|
|
|
namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys, |
|
GFP_KERNEL | GFP_DMA32); |
|
if (!namevirt) |
|
return -ENOMEM; |
|
|
|
datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys, |
|
GFP_KERNEL | GFP_DMA32); |
|
if (!datavirt) { |
|
err = -ENOMEM; |
|
goto free_namebuf; |
|
} |
|
|
|
len = strlen(filename); |
|
strncpy(namevirt, filename, namesize); |
|
|
|
if (copy_from_user(datavirt, buf, count)) { |
|
err = -EFAULT; |
|
goto free_databuf; |
|
} |
|
|
|
err = mrq_debugfs_write(bpmp, namephys, len, dataphys, |
|
count); |
|
|
|
free_databuf: |
|
dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys); |
|
free_namebuf: |
|
dma_free_coherent(bpmp->dev, namesize, namevirt, namephys); |
|
|
|
return err ?: count; |
|
} |
|
|
|
static const struct file_operations debugfs_fops = { |
|
.open = debugfs_open, |
|
.read = seq_read, |
|
.llseek = seq_lseek, |
|
.write = debugfs_store, |
|
.release = single_release, |
|
}; |
|
|
|
static int bpmp_populate_dir(struct tegra_bpmp *bpmp, struct seqbuf *seqbuf, |
|
struct dentry *parent, uint32_t depth) |
|
{ |
|
int err; |
|
uint32_t d, t; |
|
const char *name; |
|
struct dentry *dentry; |
|
|
|
while (!seqbuf_eof(seqbuf)) { |
|
err = seqbuf_read_u32(seqbuf, &d); |
|
if (err < 0) |
|
return err; |
|
|
|
if (d < depth) { |
|
seqbuf_seek(seqbuf, -4); |
|
/* go up a level */ |
|
return 0; |
|
} else if (d != depth) { |
|
/* malformed data received from BPMP */ |
|
return -EIO; |
|
} |
|
|
|
err = seqbuf_read_u32(seqbuf, &t); |
|
if (err < 0) |
|
return err; |
|
err = seqbuf_read_str(seqbuf, &name); |
|
if (err < 0) |
|
return err; |
|
|
|
if (t & DEBUGFS_S_ISDIR) { |
|
dentry = debugfs_create_dir(name, parent); |
|
if (!dentry) |
|
return -ENOMEM; |
|
err = bpmp_populate_dir(bpmp, seqbuf, dentry, depth+1); |
|
if (err < 0) |
|
return err; |
|
} else { |
|
umode_t mode; |
|
|
|
mode = t & DEBUGFS_S_IRUSR ? S_IRUSR : 0; |
|
mode |= t & DEBUGFS_S_IWUSR ? S_IWUSR : 0; |
|
dentry = debugfs_create_file(name, mode, |
|
parent, bpmp, |
|
&debugfs_fops); |
|
if (!dentry) |
|
return -ENOMEM; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int bpmp_populate_debugfs_shmem(struct tegra_bpmp *bpmp) |
|
{ |
|
struct seqbuf seqbuf; |
|
const size_t sz = SZ_512K; |
|
dma_addr_t phys; |
|
size_t nbytes; |
|
void *virt; |
|
int err; |
|
|
|
virt = dma_alloc_coherent(bpmp->dev, sz, &phys, |
|
GFP_KERNEL | GFP_DMA32); |
|
if (!virt) |
|
return -ENOMEM; |
|
|
|
err = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes); |
|
if (err < 0) { |
|
goto free; |
|
} else if (nbytes > sz) { |
|
err = -EINVAL; |
|
goto free; |
|
} |
|
|
|
seqbuf_init(&seqbuf, virt, nbytes); |
|
err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0); |
|
free: |
|
dma_free_coherent(bpmp->dev, sz, virt, phys); |
|
|
|
return err; |
|
} |
|
|
|
int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp) |
|
{ |
|
struct dentry *root; |
|
bool inband; |
|
int err; |
|
|
|
inband = tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUG); |
|
|
|
if (!inband && !tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUGFS)) |
|
return 0; |
|
|
|
root = debugfs_create_dir("bpmp", NULL); |
|
if (!root) |
|
return -ENOMEM; |
|
|
|
bpmp->debugfs_mirror = debugfs_create_dir("debug", root); |
|
if (!bpmp->debugfs_mirror) { |
|
err = -ENOMEM; |
|
goto out; |
|
} |
|
|
|
if (inband) |
|
err = bpmp_populate_debugfs_inband(bpmp, bpmp->debugfs_mirror, |
|
"/"); |
|
else |
|
err = bpmp_populate_debugfs_shmem(bpmp); |
|
|
|
out: |
|
if (err < 0) |
|
debugfs_remove_recursive(root); |
|
|
|
return err; |
|
}
|
|
|