[mirror_ubuntu-zesty-kernel.git] / drivers / staging / rdma / ipath / ipath_diag.c

/*
 * Copyright (c) 2006, 2007, 2008 QLogic Corporation. All rights reserved.
 * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*
 * This file contains support for diagnostic functions.  It is accessed by
 * opening the ipath_diag device, normally minor number 129.  Diagnostic use
 * of the InfiniPath chip may render the chip or board unusable until the
 * driver is unloaded, or in some cases, until the system is rebooted.
 *
 * Accesses to the chip through this interface are not similar to going
 * through the /sys/bus/pci resource mmap interface.
 */

#include <linux/io.h>
#include <linux/pci.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
#include <linux/export.h>
#include <asm/uaccess.h>

#include "ipath_kernel.h"
#include "ipath_common.h"

int ipath_diag_inuse;
static int diag_set_link;

static int ipath_diag_open(struct inode *in, struct file *fp);
static int ipath_diag_release(struct inode *in, struct file *fp);
static ssize_t ipath_diag_read(struct file *fp, char __user *data,
			       size_t count, loff_t *off);
static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
				size_t count, loff_t *off);

static const struct file_operations diag_file_ops = {
	.owner = THIS_MODULE,
	.write = ipath_diag_write,
	.read = ipath_diag_read,
	.open = ipath_diag_open,
	.release = ipath_diag_release,
	.llseek = default_llseek,
};

static ssize_t ipath_diagpkt_write(struct file *fp,
				   const char __user *data,
				   size_t count, loff_t *off);

static const struct file_operations diagpkt_file_ops = {
	.owner = THIS_MODULE,
	.write = ipath_diagpkt_write,
	.llseek = noop_llseek,
};

static atomic_t diagpkt_count = ATOMIC_INIT(0);
static struct cdev *diagpkt_cdev;
static struct device *diagpkt_dev;

int ipath_diag_add(struct ipath_devdata *dd)
{
	char name[16];
	int ret = 0;

	if (atomic_inc_return(&diagpkt_count) == 1) {
		ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR,
				      "ipath_diagpkt", &diagpkt_file_ops,
				      &diagpkt_cdev, &diagpkt_dev);

		if (ret) {
			ipath_dev_err(dd, "Couldn't create ipath_diagpkt "
				      "device: %d", ret);
			goto done;
		}
	}

	snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);

	ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
			      &diag_file_ops, &dd->diag_cdev,
			      &dd->diag_dev);
	if (ret)
		ipath_dev_err(dd, "Couldn't create %s device: %d",
			      name, ret);

done:
	return ret;
}

void ipath_diag_remove(struct ipath_devdata *dd)
{
	if (atomic_dec_and_test(&diagpkt_count))
		ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev);

	ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev);
}

/**
 * ipath_read_umem64 - read a 64-bit quantity from the chip into user space
 * @dd: the infinipath device
 * @uaddr: the location to store the data in user memory
 * @caddr: the source chip address (full pointer, not offset)
 * @count: number of bytes to copy (multiple of 32 bits)
 *
 * This function also localizes all chip memory accesses.
 * The copy should be written such that we read full cacheline packets
 * from the chip.  This is usually used for a single qword
 *
 * NOTE:  This assumes the chip address is 64-bit aligned.
 */
static int ipath_read_umem64(struct ipath_devdata *dd, void __user *uaddr,
			     const void __iomem *caddr, size_t count)
{
	const u64 __iomem *reg_addr = caddr;
	const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
	int ret;

	/* not very efficient, but it works for now */
	if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
		ret = -EINVAL;
		goto bail;
	}
	while (reg_addr < reg_end) {
		u64 data = readq(reg_addr);
		if (copy_to_user(uaddr, &data, sizeof(u64))) {
			ret = -EFAULT;
			goto bail;
		}
		reg_addr++;
		uaddr += sizeof(u64);
	}
	ret = 0;
bail:
	return ret;
}

/**
 * ipath_write_umem64 - write a 64-bit quantity to the chip from user space
 * @dd: the infinipath device
 * @caddr: the destination chip address (full pointer, not offset)
 * @uaddr: the source of the data in user memory
 * @count: the number of bytes to copy (multiple of 32 bits)
 *
 * This is usually used for a single qword
 * NOTE:  This assumes the chip address is 64-bit aligned.
 */

static int ipath_write_umem64(struct ipath_devdata *dd, void __iomem *caddr,
			      const void __user *uaddr, size_t count)
{
	u64 __iomem *reg_addr = caddr;
	const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
	int ret;

	/* not very efficient, but it works for now */
	if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
		ret = -EINVAL;
		goto bail;
	}
	while (reg_addr < reg_end) {
		u64 data;
		if (copy_from_user(&data, uaddr, sizeof(data))) {
			ret = -EFAULT;
			goto bail;
		}
		writeq(data, reg_addr);

		reg_addr++;
		uaddr += sizeof(u64);
	}
	ret = 0;
bail:
	return ret;
}

/**
 * ipath_read_umem32 - read a 32-bit quantity from the chip into user space
 * @dd: the infinipath device
 * @uaddr: the location to store the data in user memory
 * @caddr: the source chip address (full pointer, not offset)
 * @count: number of bytes to copy
 *
 * read 32 bit values, not 64 bit; for memories that only
 * support 32 bit reads; usually a single dword.
 */
static int ipath_read_umem32(struct ipath_devdata *dd, void __user *uaddr,
			     const void __iomem *caddr, size_t count)
{
	const u32 __iomem *reg_addr = caddr;
	const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
	int ret;

	if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
	    reg_end > (u32 __iomem *) dd->ipath_kregend) {
		ret = -EINVAL;
		goto bail;
	}
	/* not very efficient, but it works for now */
	while (reg_addr < reg_end) {
		u32 data = readl(reg_addr);
		if (copy_to_user(uaddr, &data, sizeof(data))) {
			ret = -EFAULT;
			goto bail;
		}

		reg_addr++;
		uaddr += sizeof(u32);

	}
	ret = 0;
bail:
	return ret;
}

/**
 * ipath_write_umem32 - write a 32-bit quantity to the chip from user space
 * @dd: the infinipath device
 * @caddr: the destination chip address (full pointer, not offset)
 * @uaddr: the source of the data in user memory
 * @count: number of bytes to copy
 *
 * write 32 bit values, not 64 bit; for memories that only
 * support 32 bit write; usually a single dword.
 */

static int ipath_write_umem32(struct ipath_devdata *dd, void __iomem *caddr,
			      const void __user *uaddr, size_t count)
{
	u32 __iomem *reg_addr = caddr;
	const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
	int ret;

	if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
	    reg_end > (u32 __iomem *) dd->ipath_kregend) {
		ret = -EINVAL;
		goto bail;
	}
	while (reg_addr < reg_end) {
		u32 data;
		if (copy_from_user(&data, uaddr, sizeof(data))) {
			ret = -EFAULT;
			goto bail;
		}
		writel(data, reg_addr);

		reg_addr++;
		uaddr += sizeof(u32);
	}
	ret = 0;
bail:
	return ret;
}

static int ipath_diag_open(struct inode *in, struct file *fp)
{
	int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
	struct ipath_devdata *dd;
	int ret;

	mutex_lock(&ipath_mutex);

	if (ipath_diag_inuse) {
		ret = -EBUSY;
		goto bail;
	}

	dd = ipath_lookup(unit);

	if (dd == NULL || !(dd->ipath_flags & IPATH_PRESENT) ||
	    !dd->ipath_kregbase) {
		ret = -ENODEV;
		goto bail;
	}

	fp->private_data = dd;
	ipath_diag_inuse = -2;
	diag_set_link = 0;
	ret = 0;

	/* Only expose a way to reset the device if we
	   make it into diag mode. */
	ipath_expose_reset(&dd->pcidev->dev);

bail:
	mutex_unlock(&ipath_mutex);

	return ret;
}

/**
 * ipath_diagpkt_write - write an IB packet
 * @fp: the diag data device file pointer
 * @data: ipath_diag_pkt structure saying where to get the packet
 * @count: size of data to write
 * @off: unused by this code
 */
static ssize_t ipath_diagpkt_write(struct file *fp,
				   const char __user *data,
				   size_t count, loff_t *off)
{
	u32 __iomem *piobuf;
	u32 plen, pbufn, maxlen_reserve;
	struct ipath_diag_pkt odp;
	struct ipath_diag_xpkt dp;
	u32 *tmpbuf = NULL;
	struct ipath_devdata *dd;
	ssize_t ret = 0;
	u64 val;
	u32 l_state, lt_state; /* LinkState, LinkTrainingState */


	if (count == sizeof(dp)) {
		if (copy_from_user(&dp, data, sizeof(dp))) {
			ret = -EFAULT;
			goto bail;
		}
	} else if (count == sizeof(odp)) {
		if (copy_from_user(&odp, data, sizeof(odp))) {
			ret = -EFAULT;
			goto bail;
		}
		dp.len = odp.len;
		dp.unit = odp.unit;
		dp.data = odp.data;
		dp.pbc_wd = 0;
	} else {
		ret = -EINVAL;
		goto bail;
	}

	/* send count must be an exact number of dwords */
	if (dp.len & 3) {
		ret = -EINVAL;
		goto bail;
	}

	plen = dp.len >> 2;

	dd = ipath_lookup(dp.unit);
	if (!dd || !(dd->ipath_flags & IPATH_PRESENT) ||
	    !dd->ipath_kregbase) {
		ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n",
			   dp.unit);
		ret = -ENODEV;
		goto bail;
	}

	if (ipath_diag_inuse && !diag_set_link &&
	    !(dd->ipath_flags & IPATH_LINKACTIVE)) {
		diag_set_link = 1;
		ipath_cdbg(VERBOSE, "Trying to set to set link active for "
			   "diag pkt\n");
		ipath_set_linkstate(dd, IPATH_IB_LINKARM);
		ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
	}

	if (!(dd->ipath_flags & IPATH_INITTED)) {
		/* no hardware, freeze, etc. */
		ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit);
		ret = -ENODEV;
		goto bail;
	}
	/*
	 * Want to skip check for l_state if using custom PBC,
	 * because we might be trying to force an SM packet out.
	 * first-cut, skip _all_ state checking in that case.
	 */
	val = ipath_ib_state(dd, dd->ipath_lastibcstat);
	lt_state = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat);
	l_state = ipath_ib_linkstate(dd, dd->ipath_lastibcstat);
	if (!dp.pbc_wd && (lt_state != INFINIPATH_IBCS_LT_STATE_LINKUP ||
	    (val != dd->ib_init && val != dd->ib_arm &&
	    val != dd->ib_active))) {
		ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
			   dd->ipath_unit, (unsigned long long) val);
		ret = -EINVAL;
		goto bail;
	}

	/*
	 * need total length before first word written, plus 2 Dwords. One Dword
	 * is for padding so we get the full user data when not aligned on
	 * a word boundary. The other Dword is to make sure we have room for the
	 * ICRC which gets tacked on later.
	 */
	maxlen_reserve = 2 * sizeof(u32);
	if (dp.len > dd->ipath_ibmaxlen - maxlen_reserve) {
		ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
			  dp.len, dd->ipath_ibmaxlen);
		ret = -EINVAL;
		goto bail;
	}

	plen = sizeof(u32) + dp.len;

	tmpbuf = vmalloc(plen);
	if (!tmpbuf) {
		dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, "
			 "failing\n");
		ret = -ENOMEM;
		goto bail;
	}

	if (copy_from_user(tmpbuf,
			   (const void __user *) (unsigned long) dp.data,
			   dp.len)) {
		ret = -EFAULT;
		goto bail;
	}

	plen >>= 2;		/* in dwords */

	piobuf = ipath_getpiobuf(dd, plen, &pbufn);
	if (!piobuf) {
		ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
			   dd->ipath_unit);
		ret = -EBUSY;
		goto bail;
	}
	/* disarm it just to be extra sure */
	ipath_disarm_piobufs(dd, pbufn, 1);

	if (ipath_debug & __IPATH_PKTDBG)
		ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n",
			   dd->ipath_unit, plen - 1, pbufn);

	if (dp.pbc_wd == 0)
		dp.pbc_wd = plen;
	writeq(dp.pbc_wd, piobuf);
	/*
	 * Copy all by the trigger word, then flush, so it's written
	 * to chip before trigger word, then write trigger word, then
	 * flush again, so packet is sent.
	 */
	if (dd->ipath_flags & IPATH_PIO_FLUSH_WC) {
		ipath_flush_wc();
		__iowrite32_copy(piobuf + 2, tmpbuf, plen - 1);
		ipath_flush_wc();
		__raw_writel(tmpbuf[plen - 1], piobuf + plen + 1);
	} else
		__iowrite32_copy(piobuf + 2, tmpbuf, plen);

	ipath_flush_wc();

	ret = sizeof(dp);

bail:
	vfree(tmpbuf);
	return ret;
}

static int ipath_diag_release(struct inode *in, struct file *fp)
{
	mutex_lock(&ipath_mutex);
	ipath_diag_inuse = 0;
	fp->private_data = NULL;
	mutex_unlock(&ipath_mutex);
	return 0;
}

static ssize_t ipath_diag_read(struct file *fp, char __user *data,
			       size_t count, loff_t *off)
{
	struct ipath_devdata *dd = fp->private_data;
	void __iomem *kreg_base;
	ssize_t ret;

	kreg_base = dd->ipath_kregbase;

	if (count == 0)
		ret = 0;
	else if ((count % 4) || (*off % 4))
		/* address or length is not 32-bit aligned, hence invalid */
		ret = -EINVAL;
	else if (ipath_diag_inuse < 1 && (*off || count != 8))
		ret = -EINVAL;  /* prevent cat /dev/ipath_diag* */
	else if ((count % 8) || (*off % 8))
		/* address or length not 64-bit aligned; do 32-bit reads */
		ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
	else
		ret = ipath_read_umem64(dd, data, kreg_base + *off, count);

	if (ret >= 0) {
		*off += count;
		ret = count;
		if (ipath_diag_inuse == -2)
			ipath_diag_inuse++;
	}

	return ret;
}

static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
				size_t count, loff_t *off)
{
	struct ipath_devdata *dd = fp->private_data;
	void __iomem *kreg_base;
	ssize_t ret;

	kreg_base = dd->ipath_kregbase;

	if (count == 0)
		ret = 0;
	else if ((count % 4) || (*off % 4))
		/* address or length is not 32-bit aligned, hence invalid */
		ret = -EINVAL;
	else if ((ipath_diag_inuse == -1 && (*off || count != 8)) ||
		 ipath_diag_inuse == -2)  /* read qw off 0, write qw off 0 */
		ret = -EINVAL;  /* before any other write allowed */
	else if ((count % 8) || (*off % 8))
		/* address or length not 64-bit aligned; do 32-bit writes */
		ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
	else
		ret = ipath_write_umem64(dd, kreg_base + *off, data, count);

	if (ret >= 0) {
		*off += count;
		ret = count;
		if (ipath_diag_inuse == -1)
			ipath_diag_inuse = 1; /* all read/write OK now */
	}

	return ret;
}
Commit	Line	Data
097709fe	1	/*
e7eacd36	2	* Copyright (c) 2006, 2007, 2008 QLogic Corporation. All rights reserved.
097709fe BS	3	* Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
	4	*
	5	* This software is available to you under a choice of one of two
	6	* licenses. You may choose to be licensed under the terms of the GNU
	7	* General Public License (GPL) Version 2, available from the file
	8	* COPYING in the main directory of this source tree, or the
	9	* OpenIB.org BSD license below:
	10	*
	11	* Redistribution and use in source and binary forms, with or
	12	* without modification, are permitted provided that the following
	13	* conditions are met:
	14	*
	15	* - Redistributions of source code must retain the above
	16	* copyright notice, this list of conditions and the following
	17	* disclaimer.
	18	*
	19	* - Redistributions in binary form must reproduce the above
	20	* copyright notice, this list of conditions and the following
	21	* disclaimer in the documentation and/or other materials
	22	* provided with the distribution.
	23	*
	24	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	25	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	26	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	27	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	28	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	29	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	30	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	31	* SOFTWARE.
	32	*/
	33
	34	/*
	35	* This file contains support for diagnostic functions. It is accessed by
	36	* opening the ipath_diag device, normally minor number 129. Diagnostic use
	37	* of the InfiniPath chip may render the chip or board unusable until the
	38	* driver is unloaded, or in some cases, until the system is rebooted.
	39	*
	40	* Accesses to the chip through this interface are not similar to going
	41	* through the /sys/bus/pci resource mmap interface.
	42	*/
	43
98341f26	44	#include <linux/io.h>
097709fe	45	#include <linux/pci.h>
d7b20045	46	#include <linux/vmalloc.h>
4e950f6f	47	#include <linux/fs.h>
b108d976	48	#include <linux/export.h>
097709fe BS	49	#include <asm/uaccess.h>
097709fe BS	50
097709fe	51	#include "ipath_kernel.h"
27b678dd	52	#include "ipath_common.h"
097709fe BS	53
	54	int ipath_diag_inuse;
	55	static int diag_set_link;
	56
	57	static int ipath_diag_open(struct inode in, struct file fp);
	58	static int ipath_diag_release(struct inode in, struct file fp);
	59	static ssize_t ipath_diag_read(struct file fp, char __user data,
	60	size_t count, loff_t *off);
	61	static ssize_t ipath_diag_write(struct file fp, const char __user data,
	62	size_t count, loff_t *off);
	63
2b8693c0	64	static const struct file_operations diag_file_ops = {
097709fe BS	65	.owner = THIS_MODULE,
	66	.write = ipath_diag_write,
	67	.read = ipath_diag_read,
	68	.open = ipath_diag_open,
6038f373 AB	69	.release = ipath_diag_release,
6038f373 AB	70	.llseek = default_llseek,
097709fe BS	71	};
097709fe BS	72
6ef93ddd RW	73	static ssize_t ipath_diagpkt_write(struct file *fp,
	74	const char __user *data,
	75	size_t count, loff_t *off);
	76
2b8693c0	77	static const struct file_operations diagpkt_file_ops = {
6ef93ddd RW	78	.owner = THIS_MODULE,
6ef93ddd RW	79	.write = ipath_diagpkt_write,
6038f373	80	.llseek = noop_llseek,
6ef93ddd RW	81	};
	82
	83	static atomic_t diagpkt_count = ATOMIC_INIT(0);
	84	static struct cdev *diagpkt_cdev;
f4e91eb4	85	static struct device *diagpkt_dev;
6ef93ddd	86
a2acb2ff	87	int ipath_diag_add(struct ipath_devdata *dd)
097709fe	88	{
a2acb2ff	89	char name[16];
6ef93ddd RW	90	int ret = 0;
	91
	92	if (atomic_inc_return(&diagpkt_count) == 1) {
	93	ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR,
	94	"ipath_diagpkt", &diagpkt_file_ops,
f4e91eb4	95	&diagpkt_cdev, &diagpkt_dev);
6ef93ddd RW	96
	97	if (ret) {
	98	ipath_dev_err(dd, "Couldn't create ipath_diagpkt "
	99	"device: %d", ret);
	100	goto done;
	101	}
	102	}
a2acb2ff BS	103
	104	snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);
	105
6ef93ddd RW	106	ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
6ef93ddd RW	107	&diag_file_ops, &dd->diag_cdev,
f4e91eb4	108	&dd->diag_dev);
6ef93ddd RW	109	if (ret)
	110	ipath_dev_err(dd, "Couldn't create %s device: %d",
	111	name, ret);
	112
	113	done:
	114	return ret;
097709fe BS	115	}
097709fe BS	116
a2acb2ff	117	void ipath_diag_remove(struct ipath_devdata *dd)
097709fe	118	{
6ef93ddd	119	if (atomic_dec_and_test(&diagpkt_count))
f4e91eb4	120	ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev);
6ef93ddd	121
f4e91eb4	122	ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev);
097709fe BS	123	}
	124
	125	/**
	126	* ipath_read_umem64 - read a 64-bit quantity from the chip into user space
	127	* @dd: the infinipath device
	128	* @uaddr: the location to store the data in user memory
	129	* @caddr: the source chip address (full pointer, not offset)
	130	* @count: number of bytes to copy (multiple of 32 bits)
	131	*
	132	* This function also localizes all chip memory accesses.
	133	* The copy should be written such that we read full cacheline packets
	134	* from the chip. This is usually used for a single qword
	135	*
	136	* NOTE: This assumes the chip address is 64-bit aligned.
	137	*/
	138	static int ipath_read_umem64(struct ipath_devdata dd, void __user uaddr,
	139	const void __iomem *caddr, size_t count)
	140	{
	141	const u64 __iomem *reg_addr = caddr;
	142	const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
	143	int ret;
	144
	145	/* not very efficient, but it works for now */
a2acb2ff	146	if (reg_addr < dd->ipath_kregbase \|\| reg_end > dd->ipath_kregend) {
097709fe BS	147	ret = -EINVAL;
	148	goto bail;
	149	}
	150	while (reg_addr < reg_end) {
	151	u64 data = readq(reg_addr);
	152	if (copy_to_user(uaddr, &data, sizeof(u64))) {
	153	ret = -EFAULT;
	154	goto bail;
	155	}
	156	reg_addr++;
6d8e9dd0	157	uaddr += sizeof(u64);
097709fe BS	158	}
	159	ret = 0;
	160	bail:
	161	return ret;
	162	}
	163
	164	/**
	165	* ipath_write_umem64 - write a 64-bit quantity to the chip from user space
	166	* @dd: the infinipath device
	167	* @caddr: the destination chip address (full pointer, not offset)
	168	* @uaddr: the source of the data in user memory
	169	* @count: the number of bytes to copy (multiple of 32 bits)
	170	*
	171	* This is usually used for a single qword
	172	* NOTE: This assumes the chip address is 64-bit aligned.
	173	*/
	174
	175	static int ipath_write_umem64(struct ipath_devdata dd, void __iomem caddr,
	176	const void __user *uaddr, size_t count)
	177	{
	178	u64 __iomem *reg_addr = caddr;
	179	const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
	180	int ret;
	181
	182	/* not very efficient, but it works for now */
a2acb2ff	183	if (reg_addr < dd->ipath_kregbase \|\| reg_end > dd->ipath_kregend) {
097709fe BS	184	ret = -EINVAL;
	185	goto bail;
	186	}
	187	while (reg_addr < reg_end) {
	188	u64 data;
	189	if (copy_from_user(&data, uaddr, sizeof(data))) {
	190	ret = -EFAULT;
	191	goto bail;
	192	}
	193	writeq(data, reg_addr);
	194
	195	reg_addr++;
6d8e9dd0	196	uaddr += sizeof(u64);
097709fe BS	197	}
	198	ret = 0;
	199	bail:
	200	return ret;
	201	}
	202
	203	/**
	204	* ipath_read_umem32 - read a 32-bit quantity from the chip into user space
	205	* @dd: the infinipath device
	206	* @uaddr: the location to store the data in user memory
	207	* @caddr: the source chip address (full pointer, not offset)
	208	* @count: number of bytes to copy
	209	*
	210	* read 32 bit values, not 64 bit; for memories that only
	211	* support 32 bit reads; usually a single dword.
	212	*/
	213	static int ipath_read_umem32(struct ipath_devdata dd, void __user uaddr,
	214	const void __iomem *caddr, size_t count)
	215	{
	216	const u32 __iomem *reg_addr = caddr;
	217	const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
	218	int ret;
	219
	220	if (reg_addr < (u32 __iomem *) dd->ipath_kregbase \|\|
	221	reg_end > (u32 __iomem *) dd->ipath_kregend) {
	222	ret = -EINVAL;
	223	goto bail;
	224	}
	225	/* not very efficient, but it works for now */
	226	while (reg_addr < reg_end) {
	227	u32 data = readl(reg_addr);
	228	if (copy_to_user(uaddr, &data, sizeof(data))) {
	229	ret = -EFAULT;
	230	goto bail;
	231	}
	232
	233	reg_addr++;
6d8e9dd0 BS	234	uaddr += sizeof(u32);
6d8e9dd0 BS	235
097709fe BS	236	}
	237	ret = 0;
	238	bail:
	239	return ret;
	240	}
	241
	242	/**
	243	* ipath_write_umem32 - write a 32-bit quantity to the chip from user space
	244	* @dd: the infinipath device
	245	* @caddr: the destination chip address (full pointer, not offset)
	246	* @uaddr: the source of the data in user memory
	247	* @count: number of bytes to copy
	248	*
	249	* write 32 bit values, not 64 bit; for memories that only
	250	* support 32 bit write; usually a single dword.
	251	*/
	252
	253	static int ipath_write_umem32(struct ipath_devdata dd, void __iomem caddr,
	254	const void __user *uaddr, size_t count)
	255	{
	256	u32 __iomem *reg_addr = caddr;
	257	const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
	258	int ret;
	259
	260	if (reg_addr < (u32 __iomem *) dd->ipath_kregbase \|\|
	261	reg_end > (u32 __iomem *) dd->ipath_kregend) {
	262	ret = -EINVAL;
	263	goto bail;
	264	}
	265	while (reg_addr < reg_end) {
	266	u32 data;
	267	if (copy_from_user(&data, uaddr, sizeof(data))) {
	268	ret = -EFAULT;
	269	goto bail;
	270	}
	271	writel(data, reg_addr);
	272
	273	reg_addr++;
6d8e9dd0	274	uaddr += sizeof(u32);
097709fe BS	275	}
	276	ret = 0;
	277	bail:
	278	return ret;
	279	}
	280
	281	static int ipath_diag_open(struct inode in, struct file fp)
	282	{
a2acb2ff	283	int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
097709fe	284	struct ipath_devdata *dd;
097709fe BS	285	int ret;
097709fe BS	286
097709fe	287	mutex_lock(&ipath_mutex);
097709fe BS	288
	289	if (ipath_diag_inuse) {
	290	ret = -EBUSY;
	291	goto bail;
	292	}
	293
a2acb2ff BS	294	dd = ipath_lookup(unit);
	295
	296	if (dd == NULL \|\| !(dd->ipath_flags & IPATH_PRESENT) \|\|
	297	!dd->ipath_kregbase) {
	298	ret = -ENODEV;
097709fe BS	299	goto bail;
	300	}
	301
a2acb2ff	302	fp->private_data = dd;
490462c2	303	ipath_diag_inuse = -2;
a2acb2ff BS	304	diag_set_link = 0;
a2acb2ff BS	305	ret = 0;
097709fe BS	306
	307	/* Only expose a way to reset the device if we
	308	make it into diag mode. */
a2acb2ff	309	ipath_expose_reset(&dd->pcidev->dev);
097709fe	310
a2acb2ff	311	bail:
755e4ca4 BS	312	mutex_unlock(&ipath_mutex);
755e4ca4 BS	313
097709fe BS	314	return ret;
	315	}
	316
98341f26 BS	317	/**
	318	* ipath_diagpkt_write - write an IB packet
	319	* @fp: the diag data device file pointer
	320	* @data: ipath_diag_pkt structure saying where to get the packet
	321	* @count: size of data to write
	322	* @off: unused by this code
	323	*/
	324	static ssize_t ipath_diagpkt_write(struct file *fp,
	325	const char __user *data,
	326	size_t count, loff_t *off)
	327	{
	328	u32 __iomem *piobuf;
a2cb0eb8	329	u32 plen, pbufn, maxlen_reserve;
e8e7ad71 MA	330	struct ipath_diag_pkt odp;
e8e7ad71 MA	331	struct ipath_diag_xpkt dp;
98341f26 BS	332	u32 *tmpbuf = NULL;
	333	struct ipath_devdata *dd;
	334	ssize_t ret = 0;
	335	u64 val;
58411d1c	336	u32 l_state, lt_state; /* LinkState, LinkTrainingState */
98341f26	337
98341f26	338
afd9970f MA	339	if (count == sizeof(dp)) {
	340	if (copy_from_user(&dp, data, sizeof(dp))) {
	341	ret = -EFAULT;
	342	goto bail;
	343	}
a2cb0eb8 DD	344	} else if (count == sizeof(odp)) {
	345	if (copy_from_user(&odp, data, sizeof(odp))) {
	346	ret = -EFAULT;
	347	goto bail;
	348	}
7e6d3e5c DD	349	dp.len = odp.len;
	350	dp.unit = odp.unit;
	351	dp.data = odp.data;
	352	dp.pbc_wd = 0;
a2cb0eb8 DD	353	} else {
a2cb0eb8 DD	354	ret = -EINVAL;
98341f26 BS	355	goto bail;
	356	}
	357
	358	/* send count must be an exact number of dwords */
	359	if (dp.len & 3) {
	360	ret = -EINVAL;
	361	goto bail;
	362	}
	363
a2cb0eb8	364	plen = dp.len >> 2;
98341f26 BS	365
	366	dd = ipath_lookup(dp.unit);
	367	if (!dd \|\| !(dd->ipath_flags & IPATH_PRESENT) \|\|
	368	!dd->ipath_kregbase) {
	369	ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n",
	370	dp.unit);
	371	ret = -ENODEV;
	372	goto bail;
	373	}
	374
	375	if (ipath_diag_inuse && !diag_set_link &&
	376	!(dd->ipath_flags & IPATH_LINKACTIVE)) {
	377	diag_set_link = 1;
	378	ipath_cdbg(VERBOSE, "Trying to set to set link active for "
	379	"diag pkt\n");
	380	ipath_set_linkstate(dd, IPATH_IB_LINKARM);
	381	ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
	382	}
	383
	384	if (!(dd->ipath_flags & IPATH_INITTED)) {
	385	/* no hardware, freeze, etc. */
	386	ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit);
	387	ret = -ENODEV;
	388	goto bail;
	389	}
58411d1c JG	390	/*
	391	* Want to skip check for l_state if using custom PBC,
	392	* because we might be trying to force an SM packet out.
	393	* first-cut, skip _all_ state checking in that case.
	394	*/
	395	val = ipath_ib_state(dd, dd->ipath_lastibcstat);
	396	lt_state = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat);
	397	l_state = ipath_ib_linkstate(dd, dd->ipath_lastibcstat);
	398	if (!dp.pbc_wd && (lt_state != INFINIPATH_IBCS_LT_STATE_LINKUP \|\|
	399	(val != dd->ib_init && val != dd->ib_arm &&
	400	val != dd->ib_active))) {
98341f26 BS	401	ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
	402	dd->ipath_unit, (unsigned long long) val);
	403	ret = -EINVAL;
	404	goto bail;
	405	}
	406
a2cb0eb8 DD	407	/*
	408	* need total length before first word written, plus 2 Dwords. One Dword
	409	* is for padding so we get the full user data when not aligned on
	410	* a word boundary. The other Dword is to make sure we have room for the
	411	* ICRC which gets tacked on later.
	412	*/
	413	maxlen_reserve = 2 * sizeof(u32);
	414	if (dp.len > dd->ipath_ibmaxlen - maxlen_reserve) {
98341f26	415	ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
a2cb0eb8	416	dp.len, dd->ipath_ibmaxlen);
98341f26	417	ret = -EINVAL;
a2cb0eb8	418	goto bail;
98341f26	419	}
a2cb0eb8 DD	420
	421	plen = sizeof(u32) + dp.len;
	422
98341f26 BS	423	tmpbuf = vmalloc(plen);
	424	if (!tmpbuf) {
	425	dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, "
	426	"failing\n");
	427	ret = -ENOMEM;
	428	goto bail;
	429	}
	430
	431	if (copy_from_user(tmpbuf,
	432	(const void __user *) (unsigned long) dp.data,
	433	dp.len)) {
	434	ret = -EFAULT;
	435	goto bail;
	436	}
	437
c4b4d16e RC	438	plen >>= 2; /* in dwords */
	439
	440	piobuf = ipath_getpiobuf(dd, plen, &pbufn);
98341f26 BS	441	if (!piobuf) {
	442	ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
	443	dd->ipath_unit);
	444	ret = -EBUSY;
	445	goto bail;
	446	}
58411d1c JG	447	/* disarm it just to be extra sure */
58411d1c JG	448	ipath_disarm_piobufs(dd, pbufn, 1);
98341f26	449
98341f26 BS	450	if (ipath_debug & __IPATH_PKTDBG)
	451	ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n",
	452	dd->ipath_unit, plen - 1, pbufn);
	453
e8e7ad71	454	if (dp.pbc_wd == 0)
e8e7ad71	455	dp.pbc_wd = plen;
e8e7ad71	456	writeq(dp.pbc_wd, piobuf);
210d6ca3 RC	457	/*
210d6ca3 RC	458	* Copy all by the trigger word, then flush, so it's written
98341f26	459	* to chip before trigger word, then write trigger word, then
210d6ca3 RC	460	* flush again, so packet is sent.
	461	*/
	462	if (dd->ipath_flags & IPATH_PIO_FLUSH_WC) {
	463	ipath_flush_wc();
a2cb0eb8	464	__iowrite32_copy(piobuf + 2, tmpbuf, plen - 1);
210d6ca3	465	ipath_flush_wc();
a2cb0eb8	466	__raw_writel(tmpbuf[plen - 1], piobuf + plen + 1);
210d6ca3	467	} else
a2cb0eb8	468	__iowrite32_copy(piobuf + 2, tmpbuf, plen);
210d6ca3	469
98341f26 BS	470	ipath_flush_wc();
	471
	472	ret = sizeof(dp);
	473
	474	bail:
	475	vfree(tmpbuf);
	476	return ret;
	477	}
	478
a2acb2ff	479	static int ipath_diag_release(struct inode in, struct file fp)
097709fe BS	480	{
	481	mutex_lock(&ipath_mutex);
	482	ipath_diag_inuse = 0;
a2acb2ff	483	fp->private_data = NULL;
097709fe BS	484	mutex_unlock(&ipath_mutex);
	485	return 0;
	486	}
	487
	488	static ssize_t ipath_diag_read(struct file fp, char __user data,
	489	size_t count, loff_t *off)
	490	{
a2acb2ff	491	struct ipath_devdata *dd = fp->private_data;
097709fe BS	492	void __iomem *kreg_base;
	493	ssize_t ret;
	494
097709fe BS	495	kreg_base = dd->ipath_kregbase;
	496
	497	if (count == 0)
	498	ret = 0;
	499	else if ((count % 4) \|\| (*off % 4))
	500	/* address or length is not 32-bit aligned, hence invalid */
	501	ret = -EINVAL;
490462c2 BS	502	else if (ipath_diag_inuse < 1 && (*off \|\| count != 8))
490462c2 BS	503	ret = -EINVAL; /* prevent cat /dev/ipath_diag* */
097709fe BS	504	else if ((count % 8) \|\| (*off % 8))
	505	/* address or length not 64-bit aligned; do 32-bit reads */
	506	ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
	507	else
	508	ret = ipath_read_umem64(dd, data, kreg_base + *off, count);
	509
	510	if (ret >= 0) {
	511	*off += count;
	512	ret = count;
490462c2 BS	513	if (ipath_diag_inuse == -2)
490462c2 BS	514	ipath_diag_inuse++;
097709fe BS	515	}
097709fe BS	516
097709fe BS	517	return ret;
	518	}
	519
	520	static ssize_t ipath_diag_write(struct file fp, const char __user data,
	521	size_t count, loff_t *off)
	522	{
a2acb2ff	523	struct ipath_devdata *dd = fp->private_data;
097709fe BS	524	void __iomem *kreg_base;
	525	ssize_t ret;
	526
097709fe BS	527	kreg_base = dd->ipath_kregbase;
	528
	529	if (count == 0)
	530	ret = 0;
	531	else if ((count % 4) \|\| (*off % 4))
	532	/* address or length is not 32-bit aligned, hence invalid */
	533	ret = -EINVAL;
490462c2 BS	534	else if ((ipath_diag_inuse == -1 && (*off \|\| count != 8)) \|\|
	535	ipath_diag_inuse == -2) /* read qw off 0, write qw off 0 */
	536	ret = -EINVAL; /* before any other write allowed */
097709fe BS	537	else if ((count % 8) \|\| (*off % 8))
	538	/* address or length not 64-bit aligned; do 32-bit writes */
	539	ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
	540	else
	541	ret = ipath_write_umem64(dd, kreg_base + *off, data, count);
	542
	543	if (ret >= 0) {
	544	*off += count;
	545	ret = count;
490462c2 BS	546	if (ipath_diag_inuse == -1)
490462c2 BS	547	ipath_diag_inuse = 1; /* all read/write OK now */
097709fe BS	548	}
097709fe BS	549
097709fe BS	550	return ret;
097709fe BS	551	}