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
, pbufn
, maxlen_reserve
;
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 */
339 if (count
== sizeof(dp
)) {
340 if (copy_from_user(&dp
, data
, sizeof(dp
))) {
344 } else if (count
== sizeof(odp
)) {
345 if (copy_from_user(&odp
, data
, sizeof(odp
))) {
358 /* send count must be an exact number of dwords */
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",
375 if (ipath_diag_inuse
&& !diag_set_link
&&
376 !(dd
->ipath_flags
& IPATH_LINKACTIVE
)) {
378 ipath_cdbg(VERBOSE
, "Trying to set to set link active for "
380 ipath_set_linkstate(dd
, IPATH_IB_LINKARM
);
381 ipath_set_linkstate(dd
, IPATH_IB_LINKACTIVE
);
384 if (!(dd
->ipath_flags
& IPATH_INITTED
)) {
385 /* no hardware, freeze, etc. */
386 ipath_cdbg(VERBOSE
, "unit %u not usable\n", dd
->ipath_unit
);
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.
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
))) {
401 ipath_cdbg(VERBOSE
, "unit %u not ready (state %llx)\n",
402 dd
->ipath_unit
, (unsigned long long) val
);
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.
413 maxlen_reserve
= 2 * sizeof(u32
);
414 if (dp
.len
> dd
->ipath_ibmaxlen
- maxlen_reserve
) {
415 ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
416 dp
.len
, dd
->ipath_ibmaxlen
);
421 plen
= sizeof(u32
) + dp
.len
;
423 tmpbuf
= vmalloc(plen
);
425 dev_info(&dd
->pcidev
->dev
, "Unable to allocate tmp buffer, "
431 if (copy_from_user(tmpbuf
,
432 (const void __user
*) (unsigned long) dp
.data
,
438 plen
>>= 2; /* in dwords */
440 piobuf
= ipath_getpiobuf(dd
, plen
, &pbufn
);
442 ipath_cdbg(VERBOSE
, "No PIO buffers avail unit for %u\n",
447 /* disarm it just to be extra sure */
448 ipath_disarm_piobufs(dd
, pbufn
, 1);
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
);
456 writeq(dp
.pbc_wd
, piobuf
);
458 * Copy all by the trigger word, then flush, so it's written
459 * to chip before trigger word, then write trigger word, then
460 * flush again, so packet is sent.
462 if (dd
->ipath_flags
& IPATH_PIO_FLUSH_WC
) {
464 __iowrite32_copy(piobuf
+ 2, tmpbuf
, plen
- 1);
466 __raw_writel(tmpbuf
[plen
- 1], piobuf
+ plen
+ 1);
468 __iowrite32_copy(piobuf
+ 2, tmpbuf
, plen
);
479 static int ipath_diag_release(struct inode
*in
, struct file
*fp
)
481 mutex_lock(&ipath_mutex
);
482 ipath_diag_inuse
= 0;
483 fp
->private_data
= NULL
;
484 mutex_unlock(&ipath_mutex
);
488 static ssize_t
ipath_diag_read(struct file
*fp
, char __user
*data
,
489 size_t count
, loff_t
*off
)
491 struct ipath_devdata
*dd
= fp
->private_data
;
492 void __iomem
*kreg_base
;
495 kreg_base
= dd
->ipath_kregbase
;
499 else if ((count
% 4) || (*off
% 4))
500 /* address or length is not 32-bit aligned, hence invalid */
502 else if (ipath_diag_inuse
< 1 && (*off
|| count
!= 8))
503 ret
= -EINVAL
; /* prevent cat /dev/ipath_diag* */
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
);
508 ret
= ipath_read_umem64(dd
, data
, kreg_base
+ *off
, count
);
513 if (ipath_diag_inuse
== -2)
520 static ssize_t
ipath_diag_write(struct file
*fp
, const char __user
*data
,
521 size_t count
, loff_t
*off
)
523 struct ipath_devdata
*dd
= fp
->private_data
;
524 void __iomem
*kreg_base
;
527 kreg_base
= dd
->ipath_kregbase
;
531 else if ((count
% 4) || (*off
% 4))
532 /* address or length is not 32-bit aligned, hence invalid */
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 */
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
);
541 ret
= ipath_write_umem64(dd
, kreg_base
+ *off
, data
, count
);
546 if (ipath_diag_inuse
== -1)
547 ipath_diag_inuse
= 1; /* all read/write OK now */