Commit 097924c6 authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

Merge tag 'tegra-for-4.15-firmware' of... 

Merge tag 'tegra-for-4.15-firmware' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/tegra/linux into next/drivers

Pull "firmware: tegra: Changes for v4.15-rc1" from Thierry Reding:

This contains a couple of (non-critical) fixes and improvements for the
BPMP driver as well as support for debugfs.

* tag 'tegra-for-4.15-firmware' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/tegra/linux:
  firmware: tegra: Add BPMP debugfs support
  firmware: tegra: Add stubs when BPMP not enabled
  firmware: tegra: Expose tegra_bpmp_mrq_return()
  firmware: tegra: Propagate error code to caller
parents 1c6788e8 f2381f65

drivers/firmware/tegra/Makefile

+3 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_TEGRA_BPMP)	+= bpmp.o

tegra-bpmp-y			= bpmp.o

tegra-bpmp-$(CONFIG_DEBUG_FS)	+= bpmp-debugfs.o

obj-$(CONFIG_TEGRA_BPMP)	+= tegra-bpmp.o

obj-$(CONFIG_TEGRA_IVC)		+= ivc.o

drivers/firmware/tegra/bpmp-debugfs.c

0 → 100644
+444 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 */

#include <linux/debugfs.h>

#include <linux/dma-mapping.h>

#include <linux/uaccess.h>



#include <soc/tegra/bpmp.h>

#include <soc/tegra/bpmp-abi.h>



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_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;



	*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;



	*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 ret;



	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) {

		ret = -ENOMEM;

		goto free_namebuf;

	}



	len = strlen(filename);

	strncpy(namevirt, filename, namesize);



	ret = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize,

			       &nbytes);



	if (!ret)

		seq_write(m, datavirt, nbytes);



	dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);

free_namebuf:

	dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);



	return ret;

}



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 ret;



	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) {

		ret = -ENOMEM;

		goto free_namebuf;

	}



	len = strlen(filename);

	strncpy(namevirt, filename, namesize);



	if (copy_from_user(datavirt, buf, count)) {

		ret = -EFAULT;

		goto free_databuf;

	}



	ret = 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 ret ?: 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 create_debugfs_mirror(struct tegra_bpmp *bpmp, void *buf,

				 size_t bufsize, struct dentry *root)

{

	struct seqbuf seqbuf;

	int err;



	bpmp->debugfs_mirror = debugfs_create_dir("debug", root);

	if (!bpmp->debugfs_mirror)

		return -ENOMEM;



	seqbuf_init(&seqbuf, buf, bufsize);

	err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0);

	if (err < 0) {

		debugfs_remove_recursive(bpmp->debugfs_mirror);

		bpmp->debugfs_mirror = NULL;

	}



	return err;

}



static int mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)

{

	struct mrq_query_abi_request req = { .mrq = cpu_to_le32(mrq) };

	struct mrq_query_abi_response resp;

	struct tegra_bpmp_message msg = {

		.mrq = MRQ_QUERY_ABI,

		.tx = {

			.data = &req,

			.size = sizeof(req),

		},

		.rx = {

			.data = &resp,

			.size = sizeof(resp),

		},

	};

	int ret;



	ret = tegra_bpmp_transfer(bpmp, &msg);

	if (ret < 0) {

		/* something went wrong; assume not supported */

		dev_warn(bpmp->dev, "tegra_bpmp_transfer failed (%d)\n", ret);

		return 0;

	}



	return resp.status ? 0 : 1;

}



int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)

{

	dma_addr_t phys;

	void *virt;

	const size_t sz = SZ_256K;

	size_t nbytes;

	int ret;

	struct dentry *root;



	if (!mrq_is_supported(bpmp, MRQ_DEBUGFS))

		return 0;



	root = debugfs_create_dir("bpmp", NULL);

	if (!root)

		return -ENOMEM;



	virt = dma_alloc_coherent(bpmp->dev, sz, &phys,

				  GFP_KERNEL | GFP_DMA32);

	if (!virt) {

		ret = -ENOMEM;

		goto out;

	}



	ret = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes);

	if (ret < 0)

		goto free;



	ret = create_debugfs_mirror(bpmp, virt, nbytes, root);

free:

	dma_free_coherent(bpmp->dev, sz, virt, phys);

out:

	if (ret < 0)

		debugfs_remove(root);



	return ret;

}

drivers/firmware/tegra/bpmp.c

+23 −8
Original line number Diff line number Diff line
@@ -194,16 +194,24 @@ static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel) 
}



static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,

					 void *data, size_t size)

					 void *data, size_t size, int *ret)

{

	int err;



	if (data && size > 0)

		memcpy(data, channel->ib->data, size);



	return tegra_ivc_read_advance(channel->ivc);

	err = tegra_ivc_read_advance(channel->ivc);

	if (err < 0)

		return err;



	*ret = channel->ib->code;



	return 0;

}



static ssize_t tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,

				       void *data, size_t size)

				       void *data, size_t size, int *ret)

{

	struct tegra_bpmp *bpmp = channel->bpmp;

	unsigned long flags;
@@ -217,7 +225,7 @@ static ssize_t tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel, 
	}



	spin_lock_irqsave(&bpmp->lock, flags);

	err = __tegra_bpmp_channel_read(channel, data, size);

	err = __tegra_bpmp_channel_read(channel, data, size, ret);

	clear_bit(index, bpmp->threaded.allocated);

	spin_unlock_irqrestore(&bpmp->lock, flags);
@@ -337,7 +345,8 @@ int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp, 
	if (err < 0)

		return err;



	return __tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size);

	return __tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size,

					 &msg->rx.ret);

}

EXPORT_SYMBOL_GPL(tegra_bpmp_transfer_atomic);
@@ -371,7 +380,8 @@ int tegra_bpmp_transfer(struct tegra_bpmp *bpmp, 
	if (err == 0)

		return -ETIMEDOUT;



	return tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size);

	return tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size,

				       &msg->rx.ret);

}

EXPORT_SYMBOL_GPL(tegra_bpmp_transfer);
@@ -387,8 +397,8 @@ static struct tegra_bpmp_mrq *tegra_bpmp_find_mrq(struct tegra_bpmp *bpmp, 
	return NULL;

}



static void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel,

				  int code, const void *data, size_t size)

void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,

			   const void *data, size_t size)

{

	unsigned long flags = channel->ib->flags;

	struct tegra_bpmp *bpmp = channel->bpmp;
@@ -426,6 +436,7 @@ static void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, 
		mbox_client_txdone(bpmp->mbox.channel, 0);

	}

}

EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return);



static void tegra_bpmp_handle_mrq(struct tegra_bpmp *bpmp,

				  unsigned int mrq,
@@ -824,6 +835,10 @@ static int tegra_bpmp_probe(struct platform_device *pdev) 
	if (err < 0)

		goto free_mrq;



	err = tegra_bpmp_init_debugfs(bpmp);

	if (err < 0)

		dev_err(&pdev->dev, "debugfs initialization failed: %d\n", err);



	return 0;



free_mrq:

include/soc/tegra/bpmp.h

+56 −3
Original line number Diff line number Diff line
@@ -94,10 +94,11 @@ struct tegra_bpmp { 
	struct reset_controller_dev rstc;



	struct genpd_onecell_data genpd;

};



struct tegra_bpmp *tegra_bpmp_get(struct device *dev);

void tegra_bpmp_put(struct tegra_bpmp *bpmp);

#ifdef CONFIG_DEBUG_FS

	struct dentry *debugfs_mirror;

#endif

};



struct tegra_bpmp_message {

	unsigned int mrq;
@@ -110,18 +111,60 @@ struct tegra_bpmp_message { 
	struct {

		void *data;

		size_t size;

		int ret;

	} rx;

};



#if IS_ENABLED(CONFIG_TEGRA_BPMP)

struct tegra_bpmp *tegra_bpmp_get(struct device *dev);

void tegra_bpmp_put(struct tegra_bpmp *bpmp);

int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,

			       struct tegra_bpmp_message *msg);

int tegra_bpmp_transfer(struct tegra_bpmp *bpmp,

			struct tegra_bpmp_message *msg);

void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,

			   const void *data, size_t size);



int tegra_bpmp_request_mrq(struct tegra_bpmp *bpmp, unsigned int mrq,

			   tegra_bpmp_mrq_handler_t handler, void *data);

void tegra_bpmp_free_mrq(struct tegra_bpmp *bpmp, unsigned int mrq,

			 void *data);

#else

static inline struct tegra_bpmp *tegra_bpmp_get(struct device *dev)

{

	return ERR_PTR(-ENOTSUPP);

}

static inline void tegra_bpmp_put(struct tegra_bpmp *bpmp)

{

}

static inline int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,

					     struct tegra_bpmp_message *msg)

{

	return -ENOTSUPP;

}

static inline int tegra_bpmp_transfer(struct tegra_bpmp *bpmp,

				      struct tegra_bpmp_message *msg)

{

	return -ENOTSUPP;

}

static inline void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel,

					 int code, const void *data,

					 size_t size)

{

}



static inline int tegra_bpmp_request_mrq(struct tegra_bpmp *bpmp,

					 unsigned int mrq,

					 tegra_bpmp_mrq_handler_t handler,

					 void *data)

{

	return -ENOTSUPP;

}

static inline void tegra_bpmp_free_mrq(struct tegra_bpmp *bpmp,

				       unsigned int mrq, void *data)

{

}

#endif



#if IS_ENABLED(CONFIG_CLK_TEGRA_BPMP)

int tegra_bpmp_init_clocks(struct tegra_bpmp *bpmp);
@@ -150,4 +193,14 @@ static inline int tegra_bpmp_init_powergates(struct tegra_bpmp *bpmp) 
}

#endif



#if IS_ENABLED(CONFIG_DEBUG_FS)

int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp);

#else

static inline int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)

{

	return 0;

}

#endif





#endif /* __SOC_TEGRA_BPMP_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE