Merge ../linus
[linux-2.6] / drivers / infiniband / hw / ipath / ipath_diag.c
1 /*
2  * Copyright (c) 2006 QLogic, Inc. All rights reserved.
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
44 #include <linux/io.h>
45 #include <linux/pci.h>
46 #include <linux/vmalloc.h>
47 #include <asm/uaccess.h>
48
49 #include "ipath_kernel.h"
50 #include "ipath_common.h"
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
62 static struct file_operations diag_file_ops = {
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
70 static ssize_t ipath_diagpkt_write(struct file *fp,
71                                    const char __user *data,
72                                    size_t count, loff_t *off);
73
74 static struct file_operations diagpkt_file_ops = {
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
83 int ipath_diag_add(struct ipath_devdata *dd)
84 {
85         char name[16];
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         }
99
100         snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);
101
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;
111 }
112
113 void ipath_diag_remove(struct ipath_devdata *dd)
114 {
115         if (atomic_dec_and_test(&diagpkt_count))
116                 ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_class_dev);
117
118         ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_dev);
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 */
142         if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
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++;
153                 uaddr += sizeof(u64);
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 */
179         if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
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++;
192                 uaddr += sizeof(u64);
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++;
230                 uaddr += sizeof(u32);
231
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++;
270                 uaddr += sizeof(u32);
271         }
272         ret = 0;
273 bail:
274         return ret;
275 }
276
277 static int ipath_diag_open(struct inode *in, struct file *fp)
278 {
279         int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
280         struct ipath_devdata *dd;
281         int ret;
282
283         mutex_lock(&ipath_mutex);
284
285         if (ipath_diag_inuse) {
286                 ret = -EBUSY;
287                 goto bail;
288         }
289
290         dd = ipath_lookup(unit);
291
292         if (dd == NULL || !(dd->ipath_flags & IPATH_PRESENT) ||
293             !dd->ipath_kregbase) {
294                 ret = -ENODEV;
295                 goto bail;
296         }
297
298         fp->private_data = dd;
299         ipath_diag_inuse = 1;
300         diag_set_link = 0;
301         ret = 0;
302
303         /* Only expose a way to reset the device if we
304            make it into diag mode. */
305         ipath_expose_reset(&dd->pcidev->dev);
306
307 bail:
308         mutex_unlock(&ipath_mutex);
309
310         return ret;
311 }
312
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
441 static int ipath_diag_release(struct inode *in, struct file *fp)
442 {
443         mutex_lock(&ipath_mutex);
444         ipath_diag_inuse = 0;
445         fp->private_data = NULL;
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 {
453         struct ipath_devdata *dd = fp->private_data;
454         void __iomem *kreg_base;
455         ssize_t ret;
456
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
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 {
481         struct ipath_devdata *dd = fp->private_data;
482         void __iomem *kreg_base;
483         ssize_t ret;
484
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
503         return ret;
504 }