2 * Copyright (c) 2006, 2007, 2008 QLogic Corporation. All rights reserved.
3 * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
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:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
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.
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
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.
40 * Accesses to the chip through this interface are not similar to going
41 * through the /sys/bus/pci resource mmap interface.
45 #include <linux/pci.h>
46 #include <linux/vmalloc.h>
48 #include <linux/export.h>
49 #include <asm/uaccess.h>
51 #include "ipath_kernel.h"
52 #include "ipath_common.h"
55 static int diag_set_link;
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);
64 static const struct file_operations diag_file_ops = {
66 .write = ipath_diag_write,
67 .read = ipath_diag_read,
68 .open = ipath_diag_open,
69 .release = ipath_diag_release,
70 .llseek = default_llseek,
73 static ssize_t ipath_diagpkt_write(struct file *fp,
74 const char __user *data,
75 size_t count, loff_t *off);
77 static const struct file_operations diagpkt_file_ops = {
79 .write = ipath_diagpkt_write,
80 .llseek = noop_llseek,
83 static atomic_t diagpkt_count = ATOMIC_INIT(0);
84 static struct cdev *diagpkt_cdev;
85 static struct device *diagpkt_dev;
87 int ipath_diag_add(struct ipath_devdata *dd)
92 if (atomic_inc_return(&diagpkt_count) == 1) {
93 ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR,
94 "ipath_diagpkt", &diagpkt_file_ops,
95 &diagpkt_cdev, &diagpkt_dev);
98 ipath_dev_err(dd, "Couldn't create ipath_diagpkt "
104 snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);
106 ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
107 &diag_file_ops, &dd->diag_cdev,
110 ipath_dev_err(dd, "Couldn't create %s device: %d",
117 void ipath_diag_remove(struct ipath_devdata *dd)
119 if (atomic_dec_and_test(&diagpkt_count))
120 ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev);
122 ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev);
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)
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
136 * NOTE: This assumes the chip address is 64-bit aligned.
138 static int ipath_read_umem64(struct ipath_devdata *dd, void __user *uaddr,
139 const void __iomem *caddr, size_t count)
141 const u64 __iomem *reg_addr = caddr;
142 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
145 /* not very efficient, but it works for now */
146 if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
150 while (reg_addr < reg_end) {
151 u64 data = readq(reg_addr);
152 if (copy_to_user(uaddr, &data, sizeof(u64))) {
157 uaddr += sizeof(u64);
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)
171 * This is usually used for a single qword
172 * NOTE: This assumes the chip address is 64-bit aligned.
175 static int ipath_write_umem64(struct ipath_devdata *dd, void __iomem *caddr,
176 const void __user *uaddr, size_t count)
178 u64 __iomem *reg_addr = caddr;
179 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
182 /* not very efficient, but it works for now */
183 if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
187 while (reg_addr < reg_end) {
189 if (copy_from_user(&data, uaddr, sizeof(data))) {
193 writeq(data, reg_addr);
196 uaddr += sizeof(u64);
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
210 * read 32 bit values, not 64 bit; for memories that only
211 * support 32 bit reads; usually a single dword.
213 static int ipath_read_umem32(struct ipath_devdata *dd, void __user *uaddr,
214 const void __iomem *caddr, size_t count)
216 const u32 __iomem *reg_addr = caddr;
217 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
220 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
221 reg_end > (u32 __iomem *) dd->ipath_kregend) {
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))) {
234 uaddr += sizeof(u32);
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
249 * write 32 bit values, not 64 bit; for memories that only
250 * support 32 bit write; usually a single dword.
253 static int ipath_write_umem32(struct ipath_devdata *dd, void __iomem *caddr,
254 const void __user *uaddr, size_t count)
256 u32 __iomem *reg_addr = caddr;
257 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
260 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
261 reg_end > (u32 __iomem *) dd->ipath_kregend) {
265 while (reg_addr < reg_end) {
267 if (copy_from_user(&data, uaddr, sizeof(data))) {
271 writel(data, reg_addr);
274 uaddr += sizeof(u32);
281 static int ipath_diag_open(struct inode *in, struct file *fp)
283 int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
284 struct ipath_devdata *dd;
287 mutex_lock(&ipath_mutex);
289 if (ipath_diag_inuse) {
294 dd = ipath_lookup(unit);
296 if (dd == NULL || !(dd->ipath_flags & IPATH_PRESENT) ||
297 !dd->ipath_kregbase) {
302 fp->private_data = dd;
303 ipath_diag_inuse = -2;
307 /* Only expose a way to reset the device if we
308 make it into diag mode. */
309 ipath_expose_reset(&dd->pcidev->dev);
312 mutex_unlock(&ipath_mutex);
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
324 static ssize_t ipath_diagpkt_write(struct file *fp,
325 const char __user *data,
326 size_t count, loff_t *off)
329 u32 plen, clen, pbufn;
330 struct ipath_diag_pkt odp;
331 struct ipath_diag_xpkt dp;
333 struct ipath_devdata *dd;
336 u32 l_state, lt_state; /* LinkState, LinkTrainingState */
338 if (count < sizeof(odp)) {
343 if (count == sizeof(dp)) {
344 if (copy_from_user(&dp, data, sizeof(dp))) {
348 } else if (copy_from_user(&odp, data, sizeof(odp))) {
354 * Due to padding/alignment issues (lessened with new struct)
355 * the old and new structs are the same length. We need to
356 * disambiguate them, which we can do because odp.len has never
357 * been less than the total of LRH+BTH+DETH so far, while
358 * dp.unit (same offset) unit is unlikely to get that high.
359 * Similarly, dp.data, the pointer to user at the same offset
360 * as odp.unit, is almost certainly at least one (512byte)page
361 * "above" NULL. The if-block below can be omitted if compatibility
362 * between a new driver and older diagnostic code is unimportant.
363 * compatibility the other direction (new diags, old driver) is
364 * handled in the diagnostic code, with a warning.
366 if (dp.unit >= 20 && dp.data < 512) {
367 /* very probable version mismatch. Fix it up */
368 memcpy(&odp, &dp, sizeof(odp));
369 /* We got a legacy dp, copy elements to dp */
373 dp.pbc_wd = 0; /* Indicate we need to compute PBC wd */
376 /* send count must be an exact number of dwords */
384 dd = ipath_lookup(dp.unit);
385 if (!dd || !(dd->ipath_flags & IPATH_PRESENT) ||
386 !dd->ipath_kregbase) {
387 ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n",
393 if (ipath_diag_inuse && !diag_set_link &&
394 !(dd->ipath_flags & IPATH_LINKACTIVE)) {
396 ipath_cdbg(VERBOSE, "Trying to set to set link active for "
398 ipath_set_linkstate(dd, IPATH_IB_LINKARM);
399 ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
402 if (!(dd->ipath_flags & IPATH_INITTED)) {
403 /* no hardware, freeze, etc. */
404 ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit);
409 * Want to skip check for l_state if using custom PBC,
410 * because we might be trying to force an SM packet out.
411 * first-cut, skip _all_ state checking in that case.
413 val = ipath_ib_state(dd, dd->ipath_lastibcstat);
414 lt_state = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat);
415 l_state = ipath_ib_linkstate(dd, dd->ipath_lastibcstat);
416 if (!dp.pbc_wd && (lt_state != INFINIPATH_IBCS_LT_STATE_LINKUP ||
417 (val != dd->ib_init && val != dd->ib_arm &&
418 val != dd->ib_active))) {
419 ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
420 dd->ipath_unit, (unsigned long long) val);
425 /* need total length before first word written */
426 /* +1 word is for the qword padding */
427 plen = sizeof(u32) + dp.len;
429 if ((plen + 4) > dd->ipath_ibmaxlen) {
430 ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
431 plen - 4, dd->ipath_ibmaxlen);
433 goto bail; /* before writing pbc */
435 tmpbuf = vmalloc(plen);
437 dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, "
443 if (copy_from_user(tmpbuf,
444 (const void __user *) (unsigned long) dp.data,
450 plen >>= 2; /* in dwords */
452 piobuf = ipath_getpiobuf(dd, plen, &pbufn);
454 ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
459 /* disarm it just to be extra sure */
460 ipath_disarm_piobufs(dd, pbufn, 1);
462 if (ipath_debug & __IPATH_PKTDBG)
463 ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n",
464 dd->ipath_unit, plen - 1, pbufn);
468 writeq(dp.pbc_wd, piobuf);
470 * Copy all by the trigger word, then flush, so it's written
471 * to chip before trigger word, then write trigger word, then
472 * flush again, so packet is sent.
474 if (dd->ipath_flags & IPATH_PIO_FLUSH_WC) {
476 __iowrite32_copy(piobuf + 2, tmpbuf, clen - 1);
478 __raw_writel(tmpbuf[clen - 1], piobuf + clen + 1);
480 __iowrite32_copy(piobuf + 2, tmpbuf, clen);
491 static int ipath_diag_release(struct inode *in, struct file *fp)
493 mutex_lock(&ipath_mutex);
494 ipath_diag_inuse = 0;
495 fp->private_data = NULL;
496 mutex_unlock(&ipath_mutex);
500 static ssize_t ipath_diag_read(struct file *fp, char __user *data,
501 size_t count, loff_t *off)
503 struct ipath_devdata *dd = fp->private_data;
504 void __iomem *kreg_base;
507 kreg_base = dd->ipath_kregbase;
511 else if ((count % 4) || (*off % 4))
512 /* address or length is not 32-bit aligned, hence invalid */
514 else if (ipath_diag_inuse < 1 && (*off || count != 8))
515 ret = -EINVAL; /* prevent cat /dev/ipath_diag* */
516 else if ((count % 8) || (*off % 8))
517 /* address or length not 64-bit aligned; do 32-bit reads */
518 ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
520 ret = ipath_read_umem64(dd, data, kreg_base + *off, count);
525 if (ipath_diag_inuse == -2)
532 static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
533 size_t count, loff_t *off)
535 struct ipath_devdata *dd = fp->private_data;
536 void __iomem *kreg_base;
539 kreg_base = dd->ipath_kregbase;
543 else if ((count % 4) || (*off % 4))
544 /* address or length is not 32-bit aligned, hence invalid */
546 else if ((ipath_diag_inuse == -1 && (*off || count != 8)) ||
547 ipath_diag_inuse == -2) /* read qw off 0, write qw off 0 */
548 ret = -EINVAL; /* before any other write allowed */
549 else if ((count % 8) || (*off % 8))
550 /* address or length not 64-bit aligned; do 32-bit writes */
551 ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
553 ret = ipath_write_umem64(dd, kreg_base + *off, data, count);
558 if (ipath_diag_inuse == -1)
559 ipath_diag_inuse = 1; /* all read/write OK now */