[deliverable/linux.git] / drivers / net / wireless / ath / wil6210 / ioctl.c

/*
 * Copyright (c) 2014 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <linux/uaccess.h>

#include "wil6210.h"
#include <uapi/linux/wil6210_uapi.h>

#define wil_hex_dump_ioctl(prefix_str, buf, len) \
	print_hex_dump_debug("DBG[IOC ]" prefix_str, \
			     DUMP_PREFIX_OFFSET, 16, 1, buf, len, true)
#define wil_dbg_ioctl(wil, fmt, arg...) wil_dbg(wil, "DBG[IOC ]" fmt, ##arg)

static void __iomem *wil_ioc_addr(struct wil6210_priv *wil, uint32_t addr,
				  uint32_t size, enum wil_memio_op op)
{
	void __iomem *a;
	u32 off;

	switch (op & wil_mmio_addr_mask) {
	case wil_mmio_addr_linker:
		a = wmi_buffer(wil, cpu_to_le32(addr));
		break;
	case wil_mmio_addr_ahb:
		a = wmi_addr(wil, addr);
		break;
	case wil_mmio_addr_bar:
		a = wmi_addr(wil, addr + WIL6210_FW_HOST_OFF);
		break;
	default:
		wil_err(wil, "Unsupported address mode, op = 0x%08x\n", op);
		return NULL;
	}

	off = a - wil->csr;
	if (size >= WIL6210_MEM_SIZE - off) {
		wil_err(wil, "Requested block does not fit into memory: "
			"off = 0x%08x size = 0x%08x\n", off, size);
		return NULL;
	}

	return a;
}

static int wil_ioc_memio_dword(struct wil6210_priv *wil, void __user *data)
{
	struct wil_memio io;
	void __iomem *a;
	bool need_copy = false;

	if (copy_from_user(&io, data, sizeof(io)))
		return -EFAULT;

	wil_dbg_ioctl(wil, "IO: addr = 0x%08x val = 0x%08x op = 0x%08x\n",
		      io.addr, io.val, io.op);

	a = wil_ioc_addr(wil, io.addr, sizeof(u32), io.op);
	if (!a) {
		wil_err(wil, "invalid address 0x%08x, op = 0x%08x\n", io.addr,
			io.op);
		return -EINVAL;
	}
	/* operation */
	switch (io.op & wil_mmio_op_mask) {
	case wil_mmio_read:
		io.val = readl(a);
		need_copy = true;
		break;
	case wil_mmio_write:
		writel(io.val, a);
		wmb(); /* make sure write propagated to HW */
		break;
	default:
		wil_err(wil, "Unsupported operation, op = 0x%08x\n", io.op);
		return -EINVAL;
	}

	if (need_copy) {
		wil_dbg_ioctl(wil, "IO done: addr = 0x%08x"
			      " val = 0x%08x op = 0x%08x\n",
			      io.addr, io.val, io.op);
		if (copy_to_user(data, &io, sizeof(io)))
			return -EFAULT;
	}

	return 0;
}

static int wil_ioc_memio_block(struct wil6210_priv *wil, void __user *data)
{
	struct wil_memio_block io;
	void *block;
	void __iomem *a;
	int rc = 0;

	if (copy_from_user(&io, data, sizeof(io)))
		return -EFAULT;

	wil_dbg_ioctl(wil, "IO: addr = 0x%08x size = 0x%08x op = 0x%08x\n",
		      io.addr, io.size, io.op);

	/* size */
	if (io.size % 4) {
		wil_err(wil, "size is not multiple of 4:  0x%08x\n", io.size);
		return -EINVAL;
	}

	a = wil_ioc_addr(wil, io.addr, io.size, io.op);
	if (!a) {
		wil_err(wil, "invalid address 0x%08x, op = 0x%08x\n", io.addr,
			io.op);
		return -EINVAL;
	}

	block = kmalloc(io.size, GFP_USER);
	if (!block)
		return -ENOMEM;

	/* operation */
	switch (io.op & wil_mmio_op_mask) {
	case wil_mmio_read:
		wil_memcpy_fromio_32(block, a, io.size);
		wil_hex_dump_ioctl("Read  ", block, io.size);
		if (copy_to_user(io.block, block, io.size)) {
			rc = -EFAULT;
			goto out_free;
		}
		break;
	case wil_mmio_write:
		if (copy_from_user(block, io.block, io.size)) {
			rc = -EFAULT;
			goto out_free;
		}
		wil_memcpy_toio_32(a, block, io.size);
		wmb(); /* make sure write propagated to HW */
		wil_hex_dump_ioctl("Write ", block, io.size);
		break;
	default:
		wil_err(wil, "Unsupported operation, op = 0x%08x\n", io.op);
		rc = -EINVAL;
		break;
	}

out_free:
	kfree(block);
	return rc;
}

int wil_ioctl(struct wil6210_priv *wil, void __user *data, int cmd)
{
	int ret;

	switch (cmd) {
	case WIL_IOCTL_MEMIO:
		ret = wil_ioc_memio_dword(wil, data);
		break;
	case WIL_IOCTL_MEMIO_BLOCK:
		ret = wil_ioc_memio_block(wil, data);
		break;
	default:
		wil_dbg_ioctl(wil, "Unsupported IOCTL 0x%04x\n", cmd);
		return -ENOIOCTLCMD;
	}

	wil_dbg_ioctl(wil, "ioctl(0x%04x) -> %d\n", cmd, ret);
	return ret;
}
Commit	Line	Data
dba4b74d VK	1	/*
	2	* Copyright (c) 2014 Qualcomm Atheros, Inc.
	3	*
	4	* Permission to use, copy, modify, and/or distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16
	17	#include <linux/uaccess.h>
	18
	19	#include "wil6210.h"
	20	#include <uapi/linux/wil6210_uapi.h>
	21
	22	#define wil_hex_dump_ioctl(prefix_str, buf, len) \
	23	print_hex_dump_debug("DBG[IOC ]" prefix_str, \
	24	DUMP_PREFIX_OFFSET, 16, 1, buf, len, true)
	25	#define wil_dbg_ioctl(wil, fmt, arg...) wil_dbg(wil, "DBG[IOC ]" fmt, ##arg)
	26
	27	static void __iomem wil_ioc_addr(struct wil6210_priv wil, uint32_t addr,
	28	uint32_t size, enum wil_memio_op op)
	29	{
	30	void __iomem *a;
	31	u32 off;
	32
	33	switch (op & wil_mmio_addr_mask) {
	34	case wil_mmio_addr_linker:
	35	a = wmi_buffer(wil, cpu_to_le32(addr));
	36	break;
	37	case wil_mmio_addr_ahb:
	38	a = wmi_addr(wil, addr);
	39	break;
	40	case wil_mmio_addr_bar:
	41	a = wmi_addr(wil, addr + WIL6210_FW_HOST_OFF);
	42	break;
	43	default:
	44	wil_err(wil, "Unsupported address mode, op = 0x%08x\n", op);
	45	return NULL;
	46	}
	47
	48	off = a - wil->csr;
	49	if (size >= WIL6210_MEM_SIZE - off) {
	50	wil_err(wil, "Requested block does not fit into memory: "
	51	"off = 0x%08x size = 0x%08x\n", off, size);
	52	return NULL;
	53	}
	54
	55	return a;
	56	}
	57
	58	static int wil_ioc_memio_dword(struct wil6210_priv wil, void __user data)
	59	{
	60	struct wil_memio io;
	61	void __iomem *a;
	62	bool need_copy = false;
	63
	64	if (copy_from_user(&io, data, sizeof(io)))
65	return -EFAULT;
66
67	wil_dbg_ioctl(wil, "IO: addr = 0x%08x val = 0x%08x op = 0x%08x\n",
68	io.addr, io.val, io.op);
69
70	a = wil_ioc_addr(wil, io.addr, sizeof(u32), io.op);
71	if (!a) {
72	wil_err(wil, "invalid address 0x%08x, op = 0x%08x\n", io.addr,
73	io.op);
74	return -EINVAL;
75	}
76	/* operation */
77	switch (io.op & wil_mmio_op_mask) {
78	case wil_mmio_read:
b9eeb512	79	io.val = readl(a);
dba4b74d VK	80	need_copy = true;
	81	break;
	82	case wil_mmio_write:
b9eeb512	83	writel(io.val, a);
dba4b74d VK	84	wmb(); /* make sure write propagated to HW */
	85	break;
	86	default:
	87	wil_err(wil, "Unsupported operation, op = 0x%08x\n", io.op);
	88	return -EINVAL;
	89	}
	90
	91	if (need_copy) {
	92	wil_dbg_ioctl(wil, "IO done: addr = 0x%08x"
	93	" val = 0x%08x op = 0x%08x\n",
	94	io.addr, io.val, io.op);
	95	if (copy_to_user(data, &io, sizeof(io)))
	96	return -EFAULT;
	97	}
	98
	99	return 0;
	100	}
	101
	102	static int wil_ioc_memio_block(struct wil6210_priv wil, void __user data)
	103	{
	104	struct wil_memio_block io;
	105	void *block;
	106	void __iomem *a;
	107	int rc = 0;
	108
	109	if (copy_from_user(&io, data, sizeof(io)))
	110	return -EFAULT;
	111
	112	wil_dbg_ioctl(wil, "IO: addr = 0x%08x size = 0x%08x op = 0x%08x\n",
	113	io.addr, io.size, io.op);
	114
	115	/* size */
	116	if (io.size % 4) {
	117	wil_err(wil, "size is not multiple of 4: 0x%08x\n", io.size);
	118	return -EINVAL;
	119	}
	120
	121	a = wil_ioc_addr(wil, io.addr, io.size, io.op);
	122	if (!a) {
	123	wil_err(wil, "invalid address 0x%08x, op = 0x%08x\n", io.addr,
	124	io.op);
	125	return -EINVAL;
	126	}
	127
	128	block = kmalloc(io.size, GFP_USER);
	129	if (!block)
	130	return -ENOMEM;
	131
	132	/* operation */
	133	switch (io.op & wil_mmio_op_mask) {
	134	case wil_mmio_read:
	135	wil_memcpy_fromio_32(block, a, io.size);
	136	wil_hex_dump_ioctl("Read ", block, io.size);
	137	if (copy_to_user(io.block, block, io.size)) {
	138	rc = -EFAULT;
	139	goto out_free;
	140	}
	141	break;
	142	case wil_mmio_write:
	143	if (copy_from_user(block, io.block, io.size)) {
	144	rc = -EFAULT;
	145	goto out_free;
	146	}
	147	wil_memcpy_toio_32(a, block, io.size);
148	wmb(); /* make sure write propagated to HW */
149	wil_hex_dump_ioctl("Write ", block, io.size);
150	break;
151	default:
152	wil_err(wil, "Unsupported operation, op = 0x%08x\n", io.op);
153	rc = -EINVAL;
154	break;
155	}
156
157	out_free:
158	kfree(block);
159	return rc;
160	}
161
162	int wil_ioctl(struct wil6210_priv wil, void __user data, int cmd)
163	{
6777e71c LD	164	int ret;
6777e71c LD	165
dba4b74d VK	166	switch (cmd) {
dba4b74d VK	167	case WIL_IOCTL_MEMIO:
6777e71c LD	168	ret = wil_ioc_memio_dword(wil, data);
6777e71c LD	169	break;
dba4b74d	170	case WIL_IOCTL_MEMIO_BLOCK:
6777e71c LD	171	ret = wil_ioc_memio_block(wil, data);
6777e71c LD	172	break;
dba4b74d VK	173	default:
	174	wil_dbg_ioctl(wil, "Unsupported IOCTL 0x%04x\n", cmd);
	175	return -ENOIOCTLCMD;
	176	}
6777e71c LD	177
	178	wil_dbg_ioctl(wil, "ioctl(0x%04x) -> %d\n", cmd, ret);
	179	return ret;
dba4b74d	180	}