[deliverable/linux.git] / drivers / infiniband / hw / ipath / ipath_diag.c

/*
 * Copyright (c) 2006 QLogic, Inc. 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 <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
};

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,
};

static atomic_t diagpkt_count = ATOMIC_INIT(0);
static struct cdev *diagpkt_cdev;
static struct class_device *diagpkt_class_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_class_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_class_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_class_dev);

	ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_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 = 1;
	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, clen, pbufn;
	struct ipath_diag_pkt dp;
	u32 *tmpbuf = NULL;
	struct ipath_devdata *dd;
	ssize_t ret = 0;
	u64 val;

	if (count < sizeof(dp)) {
		ret = -EINVAL;
		goto bail;
	}

	if (copy_from_user(&dp, data, sizeof(dp))) {
		ret = -EFAULT;
		goto bail;
	}

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

	clen = 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;
	}
	val = dd->ipath_lastibcstat & IPATH_IBSTATE_MASK;
	if (val != IPATH_IBSTATE_INIT && val != IPATH_IBSTATE_ARM &&
	    val != IPATH_IBSTATE_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 */
	/* +1 word is for the qword padding */
	plen = sizeof(u32) + dp.len;

	if ((plen + 4) > dd->ipath_ibmaxlen) {
		ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
			  plen - 4, dd->ipath_ibmaxlen);
		ret = -EINVAL;
		goto bail;	/* before writing pbc */
	}
	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;
	}

	piobuf = ipath_getpiobuf(dd, &pbufn);
	if (!piobuf) {
		ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
			   dd->ipath_unit);
		ret = -EBUSY;
		goto bail;
	}

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

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

	/* we have to flush after the PBC for correctness on some cpus
	 * or WC buffer can be written out of order */
	writeq(plen, piobuf);
	ipath_flush_wc();
	/* 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. */
	__iowrite32_copy(piobuf + 2, tmpbuf, clen - 1);
	ipath_flush_wc();
	__raw_writel(tmpbuf[clen - 1], piobuf + clen + 1);
	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 ((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;
	}

	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 ((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;
	}

	return ret;
}
Commit	Line	Data
097709fe	1	/*
759d5768	2	* Copyright (c) 2006 QLogic, Inc. 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>
097709fe BS	47	#include <asm/uaccess.h>
097709fe BS	48
097709fe	49	#include "ipath_kernel.h"
27b678dd	50	#include "ipath_common.h"
097709fe BS	51
	52	int ipath_diag_inuse;
	53	static int diag_set_link;
	54
	55	static int ipath_diag_open(struct inode in, struct file fp);
	56	static int ipath_diag_release(struct inode in, struct file fp);
	57	static ssize_t ipath_diag_read(struct file fp, char __user data,
	58	size_t count, loff_t *off);
	59	static ssize_t ipath_diag_write(struct file fp, const char __user data,
	60	size_t count, loff_t *off);
	61
2b8693c0	62	static const struct file_operations diag_file_ops = {
097709fe BS	63	.owner = THIS_MODULE,
	64	.write = ipath_diag_write,
	65	.read = ipath_diag_read,
	66	.open = ipath_diag_open,
	67	.release = ipath_diag_release
	68	};
	69
6ef93ddd RW	70	static ssize_t ipath_diagpkt_write(struct file *fp,
	71	const char __user *data,
	72	size_t count, loff_t *off);
	73
2b8693c0	74	static const struct file_operations diagpkt_file_ops = {
6ef93ddd RW	75	.owner = THIS_MODULE,
	76	.write = ipath_diagpkt_write,
	77	};
	78
	79	static atomic_t diagpkt_count = ATOMIC_INIT(0);
	80	static struct cdev *diagpkt_cdev;
	81	static struct class_device *diagpkt_class_dev;
	82
a2acb2ff	83	int ipath_diag_add(struct ipath_devdata *dd)
097709fe	84	{
a2acb2ff	85	char name[16];
6ef93ddd RW	86	int ret = 0;
	87
	88	if (atomic_inc_return(&diagpkt_count) == 1) {
	89	ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR,
	90	"ipath_diagpkt", &diagpkt_file_ops,
	91	&diagpkt_cdev, &diagpkt_class_dev);
	92
	93	if (ret) {
	94	ipath_dev_err(dd, "Couldn't create ipath_diagpkt "
	95	"device: %d", ret);
	96	goto done;
	97	}
	98	}
a2acb2ff BS	99
	100	snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);
	101
6ef93ddd RW	102	ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
	103	&diag_file_ops, &dd->diag_cdev,
	104	&dd->diag_class_dev);
	105	if (ret)
	106	ipath_dev_err(dd, "Couldn't create %s device: %d",
	107	name, ret);
	108
	109	done:
	110	return ret;
097709fe BS	111	}
097709fe BS	112
a2acb2ff	113	void ipath_diag_remove(struct ipath_devdata *dd)
097709fe	114	{
6ef93ddd RW	115	if (atomic_dec_and_test(&diagpkt_count))
	116	ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_class_dev);
	117
a2acb2ff	118	ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_dev);
097709fe BS	119	}
	120
	121	/**
	122	* ipath_read_umem64 - read a 64-bit quantity from the chip into user space
	123	* @dd: the infinipath device
	124	* @uaddr: the location to store the data in user memory
	125	* @caddr: the source chip address (full pointer, not offset)
	126	* @count: number of bytes to copy (multiple of 32 bits)
	127	*
	128	* This function also localizes all chip memory accesses.
	129	* The copy should be written such that we read full cacheline packets
	130	* from the chip. This is usually used for a single qword
	131	*
	132	* NOTE: This assumes the chip address is 64-bit aligned.
	133	*/
	134	static int ipath_read_umem64(struct ipath_devdata dd, void __user uaddr,
	135	const void __iomem *caddr, size_t count)
	136	{
	137	const u64 __iomem *reg_addr = caddr;
	138	const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
	139	int ret;
	140
	141	/* not very efficient, but it works for now */
a2acb2ff	142	if (reg_addr < dd->ipath_kregbase \|\| reg_end > dd->ipath_kregend) {
097709fe BS	143	ret = -EINVAL;
	144	goto bail;
	145	}
	146	while (reg_addr < reg_end) {
	147	u64 data = readq(reg_addr);
	148	if (copy_to_user(uaddr, &data, sizeof(u64))) {
	149	ret = -EFAULT;
	150	goto bail;
	151	}
	152	reg_addr++;
6d8e9dd0	153	uaddr += sizeof(u64);
097709fe BS	154	}
	155	ret = 0;
	156	bail:
	157	return ret;
	158	}
	159
	160	/**
	161	* ipath_write_umem64 - write a 64-bit quantity to the chip from user space
	162	* @dd: the infinipath device
	163	* @caddr: the destination chip address (full pointer, not offset)
	164	* @uaddr: the source of the data in user memory
	165	* @count: the number of bytes to copy (multiple of 32 bits)
	166	*
	167	* This is usually used for a single qword
	168	* NOTE: This assumes the chip address is 64-bit aligned.
	169	*/
	170
	171	static int ipath_write_umem64(struct ipath_devdata dd, void __iomem caddr,
	172	const void __user *uaddr, size_t count)
	173	{
	174	u64 __iomem *reg_addr = caddr;
	175	const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
	176	int ret;
	177
	178	/* not very efficient, but it works for now */
a2acb2ff	179	if (reg_addr < dd->ipath_kregbase \|\| reg_end > dd->ipath_kregend) {
097709fe BS	180	ret = -EINVAL;
	181	goto bail;
	182	}
	183	while (reg_addr < reg_end) {
	184	u64 data;
	185	if (copy_from_user(&data, uaddr, sizeof(data))) {
	186	ret = -EFAULT;
	187	goto bail;
	188	}
	189	writeq(data, reg_addr);
	190
	191	reg_addr++;
6d8e9dd0	192	uaddr += sizeof(u64);
097709fe BS	193	}
	194	ret = 0;
	195	bail:
	196	return ret;
	197	}
	198
	199	/**
	200	* ipath_read_umem32 - read a 32-bit quantity from the chip into user space
	201	* @dd: the infinipath device
	202	* @uaddr: the location to store the data in user memory
	203	* @caddr: the source chip address (full pointer, not offset)
	204	* @count: number of bytes to copy
	205	*
	206	* read 32 bit values, not 64 bit; for memories that only
	207	* support 32 bit reads; usually a single dword.
	208	*/
	209	static int ipath_read_umem32(struct ipath_devdata dd, void __user uaddr,
	210	const void __iomem *caddr, size_t count)
	211	{
	212	const u32 __iomem *reg_addr = caddr;
	213	const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
	214	int ret;
	215
	216	if (reg_addr < (u32 __iomem *) dd->ipath_kregbase \|\|
	217	reg_end > (u32 __iomem *) dd->ipath_kregend) {
	218	ret = -EINVAL;
	219	goto bail;
	220	}
	221	/* not very efficient, but it works for now */
	222	while (reg_addr < reg_end) {
	223	u32 data = readl(reg_addr);
	224	if (copy_to_user(uaddr, &data, sizeof(data))) {
	225	ret = -EFAULT;
	226	goto bail;
	227	}
	228
	229	reg_addr++;
6d8e9dd0 BS	230	uaddr += sizeof(u32);
6d8e9dd0 BS	231
097709fe BS	232	}
	233	ret = 0;
	234	bail:
	235	return ret;
	236	}
	237
	238	/**
	239	* ipath_write_umem32 - write a 32-bit quantity to the chip from user space
	240	* @dd: the infinipath device
	241	* @caddr: the destination chip address (full pointer, not offset)
	242	* @uaddr: the source of the data in user memory
	243	* @count: number of bytes to copy
	244	*
	245	* write 32 bit values, not 64 bit; for memories that only
	246	* support 32 bit write; usually a single dword.
	247	*/
	248
	249	static int ipath_write_umem32(struct ipath_devdata dd, void __iomem caddr,
	250	const void __user *uaddr, size_t count)
	251	{
	252	u32 __iomem *reg_addr = caddr;
	253	const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
	254	int ret;
	255
	256	if (reg_addr < (u32 __iomem *) dd->ipath_kregbase \|\|
	257	reg_end > (u32 __iomem *) dd->ipath_kregend) {
	258	ret = -EINVAL;
	259	goto bail;
	260	}
	261	while (reg_addr < reg_end) {
	262	u32 data;
	263	if (copy_from_user(&data, uaddr, sizeof(data))) {
	264	ret = -EFAULT;
	265	goto bail;
	266	}
	267	writel(data, reg_addr);
	268
	269	reg_addr++;
6d8e9dd0	270	uaddr += sizeof(u32);
097709fe BS	271	}
	272	ret = 0;
	273	bail:
	274	return ret;
	275	}
	276
	277	static int ipath_diag_open(struct inode in, struct file fp)
	278	{
a2acb2ff	279	int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
097709fe	280	struct ipath_devdata *dd;
097709fe BS	281	int ret;
097709fe BS	282
097709fe	283	mutex_lock(&ipath_mutex);
097709fe BS	284
	285	if (ipath_diag_inuse) {
	286	ret = -EBUSY;
	287	goto bail;
	288	}
	289
a2acb2ff BS	290	dd = ipath_lookup(unit);
	291
	292	if (dd == NULL \|\| !(dd->ipath_flags & IPATH_PRESENT) \|\|
	293	!dd->ipath_kregbase) {
	294	ret = -ENODEV;
097709fe BS	295	goto bail;
	296	}
	297
a2acb2ff BS	298	fp->private_data = dd;
	299	ipath_diag_inuse = 1;
	300	diag_set_link = 0;
	301	ret = 0;
097709fe BS	302
	303	/* Only expose a way to reset the device if we
	304	make it into diag mode. */
a2acb2ff	305	ipath_expose_reset(&dd->pcidev->dev);
097709fe	306
a2acb2ff	307	bail:
755e4ca4 BS	308	mutex_unlock(&ipath_mutex);
755e4ca4 BS	309
097709fe BS	310	return ret;
	311	}
	312
98341f26 BS	313	/**
	314	* ipath_diagpkt_write - write an IB packet
	315	* @fp: the diag data device file pointer
	316	* @data: ipath_diag_pkt structure saying where to get the packet
	317	* @count: size of data to write
	318	* @off: unused by this code
	319	*/
	320	static ssize_t ipath_diagpkt_write(struct file *fp,
	321	const char __user *data,
	322	size_t count, loff_t *off)
	323	{
	324	u32 __iomem *piobuf;
	325	u32 plen, clen, pbufn;
	326	struct ipath_diag_pkt dp;
	327	u32 *tmpbuf = NULL;
	328	struct ipath_devdata *dd;
	329	ssize_t ret = 0;
	330	u64 val;
	331
	332	if (count < sizeof(dp)) {
	333	ret = -EINVAL;
	334	goto bail;
	335	}
	336
	337	if (copy_from_user(&dp, data, sizeof(dp))) {
	338	ret = -EFAULT;
	339	goto bail;
	340	}
	341
	342	/* send count must be an exact number of dwords */
	343	if (dp.len & 3) {
	344	ret = -EINVAL;
	345	goto bail;
	346	}
	347
	348	clen = dp.len >> 2;
	349
	350	dd = ipath_lookup(dp.unit);
	351	if (!dd \|\| !(dd->ipath_flags & IPATH_PRESENT) \|\|
	352	!dd->ipath_kregbase) {
	353	ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n",
	354	dp.unit);
	355	ret = -ENODEV;
	356	goto bail;
	357	}
	358
	359	if (ipath_diag_inuse && !diag_set_link &&
	360	!(dd->ipath_flags & IPATH_LINKACTIVE)) {
	361	diag_set_link = 1;
	362	ipath_cdbg(VERBOSE, "Trying to set to set link active for "
	363	"diag pkt\n");
	364	ipath_set_linkstate(dd, IPATH_IB_LINKARM);
	365	ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
	366	}
	367
	368	if (!(dd->ipath_flags & IPATH_INITTED)) {
	369	/* no hardware, freeze, etc. */
	370	ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit);
	371	ret = -ENODEV;
	372	goto bail;
	373	}
	374	val = dd->ipath_lastibcstat & IPATH_IBSTATE_MASK;
	375	if (val != IPATH_IBSTATE_INIT && val != IPATH_IBSTATE_ARM &&
	376	val != IPATH_IBSTATE_ACTIVE) {
377	ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
378	dd->ipath_unit, (unsigned long long) val);
379	ret = -EINVAL;
380	goto bail;
381	}
382
383	/* need total length before first word written */
384	/* +1 word is for the qword padding */
385	plen = sizeof(u32) + dp.len;
386
387	if ((plen + 4) > dd->ipath_ibmaxlen) {
388	ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
389	plen - 4, dd->ipath_ibmaxlen);
390	ret = -EINVAL;
391	goto bail; /* before writing pbc */
392	}
393	tmpbuf = vmalloc(plen);
394	if (!tmpbuf) {
395	dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, "
396	"failing\n");
397	ret = -ENOMEM;
398	goto bail;
399	}
400
401	if (copy_from_user(tmpbuf,
402	(const void __user *) (unsigned long) dp.data,
403	dp.len)) {
404	ret = -EFAULT;
405	goto bail;
406	}
407
408	piobuf = ipath_getpiobuf(dd, &pbufn);
409	if (!piobuf) {
410	ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
411	dd->ipath_unit);
412	ret = -EBUSY;
413	goto bail;
414	}
415
416	plen >>= 2; /* in dwords */
417
418	if (ipath_debug & __IPATH_PKTDBG)
419	ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n",
420	dd->ipath_unit, plen - 1, pbufn);
421
422	/* we have to flush after the PBC for correctness on some cpus
423	* or WC buffer can be written out of order */
424	writeq(plen, piobuf);
425	ipath_flush_wc();
426	/* copy all by the trigger word, then flush, so it's written
427	* to chip before trigger word, then write trigger word, then
428	* flush again, so packet is sent. */
429	__iowrite32_copy(piobuf + 2, tmpbuf, clen - 1);
430	ipath_flush_wc();
431	__raw_writel(tmpbuf[clen - 1], piobuf + clen + 1);
432	ipath_flush_wc();
433
434	ret = sizeof(dp);
435
436	bail:
437	vfree(tmpbuf);
438	return ret;
439	}
440
a2acb2ff	441	static int ipath_diag_release(struct inode in, struct file fp)
097709fe BS	442	{
	443	mutex_lock(&ipath_mutex);
	444	ipath_diag_inuse = 0;
a2acb2ff	445	fp->private_data = NULL;
097709fe BS	446	mutex_unlock(&ipath_mutex);
	447	return 0;
	448	}
	449
	450	static ssize_t ipath_diag_read(struct file fp, char __user data,
	451	size_t count, loff_t *off)
	452	{
a2acb2ff	453	struct ipath_devdata *dd = fp->private_data;
097709fe BS	454	void __iomem *kreg_base;
	455	ssize_t ret;
	456
097709fe BS	457	kreg_base = dd->ipath_kregbase;
	458
	459	if (count == 0)
	460	ret = 0;
	461	else if ((count % 4) \|\| (*off % 4))
	462	/* address or length is not 32-bit aligned, hence invalid */
	463	ret = -EINVAL;
	464	else if ((count % 8) \|\| (*off % 8))
	465	/* address or length not 64-bit aligned; do 32-bit reads */
	466	ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
	467	else
	468	ret = ipath_read_umem64(dd, data, kreg_base + *off, count);
	469
	470	if (ret >= 0) {
	471	*off += count;
	472	ret = count;
	473	}
	474
097709fe BS	475	return ret;
	476	}
	477
	478	static ssize_t ipath_diag_write(struct file fp, const char __user data,
	479	size_t count, loff_t *off)
	480	{
a2acb2ff	481	struct ipath_devdata *dd = fp->private_data;
097709fe BS	482	void __iomem *kreg_base;
	483	ssize_t ret;
	484
097709fe BS	485	kreg_base = dd->ipath_kregbase;
	486
	487	if (count == 0)
	488	ret = 0;
	489	else if ((count % 4) \|\| (*off % 4))
	490	/* address or length is not 32-bit aligned, hence invalid */
	491	ret = -EINVAL;
	492	else if ((count % 8) \|\| (*off % 8))
	493	/* address or length not 64-bit aligned; do 32-bit writes */
	494	ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
	495	else
	496	ret = ipath_write_umem64(dd, kreg_base + *off, data, count);
	497
	498	if (ret >= 0) {
	499	*off += count;
	500	ret = count;
	501	}
	502
097709fe BS	503	return ret;
097709fe BS	504	}