2 * Copyright (c) 2006 QLogic, Inc. 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.
44 #include <linux/pci.h>
45 #include <asm/uaccess.h>
47 #include "ipath_common.h"
48 #include "ipath_kernel.h"
49 #include "ips_common.h"
50 #include "ipath_layer.h"
53 static int diag_set_link;
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);
62 static struct file_operations diag_file_ops = {
64 .write = ipath_diag_write,
65 .read = ipath_diag_read,
66 .open = ipath_diag_open,
67 .release = ipath_diag_release
70 static struct cdev *diag_cdev;
71 static struct class_device *diag_class_dev;
73 int ipath_diag_init(void)
75 return ipath_cdev_init(IPATH_DIAG_MINOR, "ipath_diag",
76 &diag_file_ops, &diag_cdev, &diag_class_dev);
79 void ipath_diag_cleanup(void)
81 ipath_cdev_cleanup(&diag_cdev, &diag_class_dev);
85 * ipath_read_umem64 - read a 64-bit quantity from the chip into user space
86 * @dd: the infinipath device
87 * @uaddr: the location to store the data in user memory
88 * @caddr: the source chip address (full pointer, not offset)
89 * @count: number of bytes to copy (multiple of 32 bits)
91 * This function also localizes all chip memory accesses.
92 * The copy should be written such that we read full cacheline packets
93 * from the chip. This is usually used for a single qword
95 * NOTE: This assumes the chip address is 64-bit aligned.
97 static int ipath_read_umem64(struct ipath_devdata *dd, void __user *uaddr,
98 const void __iomem *caddr, size_t count)
100 const u64 __iomem *reg_addr = caddr;
101 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
104 /* not very efficient, but it works for now */
105 if (reg_addr < dd->ipath_kregbase ||
106 reg_end > dd->ipath_kregend) {
110 while (reg_addr < reg_end) {
111 u64 data = readq(reg_addr);
112 if (copy_to_user(uaddr, &data, sizeof(u64))) {
125 * ipath_write_umem64 - write a 64-bit quantity to the chip from user space
126 * @dd: the infinipath device
127 * @caddr: the destination chip address (full pointer, not offset)
128 * @uaddr: the source of the data in user memory
129 * @count: the number of bytes to copy (multiple of 32 bits)
131 * This is usually used for a single qword
132 * NOTE: This assumes the chip address is 64-bit aligned.
135 static int ipath_write_umem64(struct ipath_devdata *dd, void __iomem *caddr,
136 const void __user *uaddr, size_t count)
138 u64 __iomem *reg_addr = caddr;
139 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
142 /* not very efficient, but it works for now */
143 if (reg_addr < dd->ipath_kregbase ||
144 reg_end > dd->ipath_kregend) {
148 while (reg_addr < reg_end) {
150 if (copy_from_user(&data, uaddr, sizeof(data))) {
154 writeq(data, reg_addr);
165 * ipath_read_umem32 - read a 32-bit quantity from the chip into user space
166 * @dd: the infinipath device
167 * @uaddr: the location to store the data in user memory
168 * @caddr: the source chip address (full pointer, not offset)
169 * @count: number of bytes to copy
171 * read 32 bit values, not 64 bit; for memories that only
172 * support 32 bit reads; usually a single dword.
174 static int ipath_read_umem32(struct ipath_devdata *dd, void __user *uaddr,
175 const void __iomem *caddr, size_t count)
177 const u32 __iomem *reg_addr = caddr;
178 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
181 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
182 reg_end > (u32 __iomem *) dd->ipath_kregend) {
186 /* not very efficient, but it works for now */
187 while (reg_addr < reg_end) {
188 u32 data = readl(reg_addr);
189 if (copy_to_user(uaddr, &data, sizeof(data))) {
203 * ipath_write_umem32 - write a 32-bit quantity to the chip from user space
204 * @dd: the infinipath device
205 * @caddr: the destination chip address (full pointer, not offset)
206 * @uaddr: the source of the data in user memory
207 * @count: number of bytes to copy
209 * write 32 bit values, not 64 bit; for memories that only
210 * support 32 bit write; usually a single dword.
213 static int ipath_write_umem32(struct ipath_devdata *dd, void __iomem *caddr,
214 const void __user *uaddr, size_t count)
216 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 while (reg_addr < reg_end) {
227 if (copy_from_user(&data, uaddr, sizeof(data))) {
231 writel(data, reg_addr);
241 static int ipath_diag_open(struct inode *in, struct file *fp)
243 struct ipath_devdata *dd;
244 int unit = 0; /* XXX this is bogus */
248 dd = ipath_lookup(unit);
250 mutex_lock(&ipath_mutex);
251 spin_lock_irqsave(&ipath_devs_lock, flags);
253 if (ipath_diag_inuse) {
258 list_for_each_entry(dd, &ipath_dev_list, ipath_list) {
260 * we need at least one infinipath device to be present
261 * (don't use INITTED, because we want to be able to open
262 * even if device is in freeze mode, which cleared INITTED).
263 * There is a small amount of risk to this, which is why we
264 * also verify kregbase is set.
267 if (!(dd->ipath_flags & IPATH_PRESENT) ||
271 ipath_diag_inuse = 1;
280 spin_unlock_irqrestore(&ipath_devs_lock, flags);
282 /* Only expose a way to reset the device if we
283 make it into diag mode. */
285 ipath_expose_reset(&dd->pcidev->dev);
287 mutex_unlock(&ipath_mutex);
292 static int ipath_diag_release(struct inode *i, struct file *f)
294 mutex_lock(&ipath_mutex);
295 ipath_diag_inuse = 0;
296 mutex_unlock(&ipath_mutex);
300 static ssize_t ipath_diag_read(struct file *fp, char __user *data,
301 size_t count, loff_t *off)
303 int unit = 0; /* XXX provide for reads on other units some day */
304 struct ipath_devdata *dd;
305 void __iomem *kreg_base;
308 dd = ipath_lookup(unit);
314 kreg_base = dd->ipath_kregbase;
318 else if ((count % 4) || (*off % 4))
319 /* address or length is not 32-bit aligned, hence invalid */
321 else if ((count % 8) || (*off % 8))
322 /* address or length not 64-bit aligned; do 32-bit reads */
323 ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
325 ret = ipath_read_umem64(dd, data, kreg_base + *off, count);
336 static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
337 size_t count, loff_t *off)
339 int unit = 0; /* XXX this is bogus */
340 struct ipath_devdata *dd;
341 void __iomem *kreg_base;
344 dd = ipath_lookup(unit);
349 kreg_base = dd->ipath_kregbase;
353 else if ((count % 4) || (*off % 4))
354 /* address or length is not 32-bit aligned, hence invalid */
356 else if ((count % 8) || (*off % 8))
357 /* address or length not 64-bit aligned; do 32-bit writes */
358 ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
360 ret = ipath_write_umem64(dd, kreg_base + *off, data, count);