1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include <linux/io.h>
46#include <linux/pci.h>
47#include <linux/poll.h>
48#include <linux/vmalloc.h>
49#include <linux/export.h>
50#include <linux/fs.h>
51#include <linux/uaccess.h>
52
53#include "qib.h"
54#include "qib_common.h"
55
56#undef pr_fmt
57#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
58
59
60
61
62
63
64enum diag_state { UNUSED = 0, OPENED, INIT, READY };
65
66
67static struct qib_diag_client {
68 struct qib_diag_client *next;
69 struct qib_devdata *dd;
70 pid_t pid;
71 enum diag_state state;
72} *client_pool;
73
74
75
76
77
78static struct qib_diag_client *get_client(struct qib_devdata *dd)
79{
80 struct qib_diag_client *dc;
81
82 dc = client_pool;
83 if (dc)
84
85 client_pool = dc->next;
86 else
87
88 dc = kmalloc(sizeof *dc, GFP_KERNEL);
89
90 if (dc) {
91 dc->next = NULL;
92 dc->dd = dd;
93 dc->pid = current->pid;
94 dc->state = OPENED;
95 }
96 return dc;
97}
98
99
100
101
102static void return_client(struct qib_diag_client *dc)
103{
104 struct qib_devdata *dd = dc->dd;
105 struct qib_diag_client *tdc, *rdc;
106
107 rdc = NULL;
108 if (dc == dd->diag_client) {
109 dd->diag_client = dc->next;
110 rdc = dc;
111 } else {
112 tdc = dc->dd->diag_client;
113 while (tdc) {
114 if (dc == tdc->next) {
115 tdc->next = dc->next;
116 rdc = dc;
117 break;
118 }
119 tdc = tdc->next;
120 }
121 }
122 if (rdc) {
123 rdc->state = UNUSED;
124 rdc->dd = NULL;
125 rdc->pid = 0;
126 rdc->next = client_pool;
127 client_pool = rdc;
128 }
129}
130
131static int qib_diag_open(struct inode *in, struct file *fp);
132static int qib_diag_release(struct inode *in, struct file *fp);
133static ssize_t qib_diag_read(struct file *fp, char __user *data,
134 size_t count, loff_t *off);
135static ssize_t qib_diag_write(struct file *fp, const char __user *data,
136 size_t count, loff_t *off);
137
138static const struct file_operations diag_file_ops = {
139 .owner = THIS_MODULE,
140 .write = qib_diag_write,
141 .read = qib_diag_read,
142 .open = qib_diag_open,
143 .release = qib_diag_release,
144 .llseek = default_llseek,
145};
146
147static atomic_t diagpkt_count = ATOMIC_INIT(0);
148static struct cdev *diagpkt_cdev;
149static struct device *diagpkt_device;
150
151static ssize_t qib_diagpkt_write(struct file *fp, const char __user *data,
152 size_t count, loff_t *off);
153
154static const struct file_operations diagpkt_file_ops = {
155 .owner = THIS_MODULE,
156 .write = qib_diagpkt_write,
157 .llseek = noop_llseek,
158};
159
160int qib_diag_add(struct qib_devdata *dd)
161{
162 char name[16];
163 int ret = 0;
164
165 if (atomic_inc_return(&diagpkt_count) == 1) {
166 ret = qib_cdev_init(QIB_DIAGPKT_MINOR, "ipath_diagpkt",
167 &diagpkt_file_ops, &diagpkt_cdev,
168 &diagpkt_device);
169 if (ret)
170 goto done;
171 }
172
173 snprintf(name, sizeof(name), "ipath_diag%d", dd->unit);
174 ret = qib_cdev_init(QIB_DIAG_MINOR_BASE + dd->unit, name,
175 &diag_file_ops, &dd->diag_cdev,
176 &dd->diag_device);
177done:
178 return ret;
179}
180
181static void qib_unregister_observers(struct qib_devdata *dd);
182
183void qib_diag_remove(struct qib_devdata *dd)
184{
185 struct qib_diag_client *dc;
186
187 if (atomic_dec_and_test(&diagpkt_count))
188 qib_cdev_cleanup(&diagpkt_cdev, &diagpkt_device);
189
190 qib_cdev_cleanup(&dd->diag_cdev, &dd->diag_device);
191
192
193
194
195
196 while (dd->diag_client)
197 return_client(dd->diag_client);
198
199
200 while (client_pool) {
201 dc = client_pool;
202 client_pool = dc->next;
203 kfree(dc);
204 }
205
206 qib_unregister_observers(dd);
207}
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
235 u32 *cntp)
236{
237 u32 kreglen;
238 u32 snd_bottom, snd_lim = 0;
239 u32 __iomem *krb32 = (u32 __iomem *)dd->kregbase;
240 u32 __iomem *map = NULL;
241 u32 cnt = 0;
242 u32 tot4k, offs4k;
243
244
245 kreglen = (dd->kregend - dd->kregbase) * sizeof(u64);
246 if (offset < kreglen) {
247 map = krb32 + (offset / sizeof(u32));
248 cnt = kreglen - offset;
249 goto mapped;
250 }
251
252
253
254
255
256
257 if (dd->userbase) {
258
259 u32 ulim = (dd->cfgctxts * dd->ureg_align) + dd->uregbase;
260 if (!dd->piovl15base)
261 snd_lim = dd->uregbase;
262 krb32 = (u32 __iomem *)dd->userbase;
263 if (offset >= dd->uregbase && offset < ulim) {
264 map = krb32 + (offset - dd->uregbase) / sizeof(u32);
265 cnt = ulim - offset;
266 goto mapped;
267 }
268 }
269
270
271
272
273
274
275
276
277
278
279
280 snd_bottom = dd->pio2k_bufbase;
281 if (snd_lim == 0) {
282 u32 tot2k = dd->piobcnt2k * ALIGN(dd->piosize2k, dd->palign);
283 snd_lim = snd_bottom + tot2k;
284 }
285
286
287
288 tot4k = dd->piobcnt4k * dd->align4k;
289 offs4k = dd->piobufbase >> 32;
290 if (dd->piobcnt4k) {
291 if (snd_bottom > offs4k)
292 snd_bottom = offs4k;
293 else {
294
295 if (!dd->userbase || dd->piovl15base)
296 snd_lim = offs4k + tot4k;
297 }
298 }
299
300
301
302
303 if (offset >= snd_bottom && offset < snd_lim) {
304 offset -= snd_bottom;
305 map = (u32 __iomem *)dd->piobase + (offset / sizeof(u32));
306 cnt = snd_lim - offset;
307 }
308
309 if (!map && offs4k && dd->piovl15base) {
310 snd_lim = offs4k + tot4k + 2 * dd->align4k;
311 if (offset >= (offs4k + tot4k) && offset < snd_lim) {
312 map = (u32 __iomem *)dd->piovl15base +
313 ((offset - (offs4k + tot4k)) / sizeof(u32));
314 cnt = snd_lim - offset;
315 }
316 }
317
318mapped:
319 if (cntp)
320 *cntp = cnt;
321 return map;
322}
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337static int qib_read_umem64(struct qib_devdata *dd, void __user *uaddr,
338 u32 regoffs, size_t count)
339{
340 const u64 __iomem *reg_addr;
341 const u64 __iomem *reg_end;
342 u32 limit;
343 int ret;
344
345 reg_addr = (const u64 __iomem *)qib_remap_ioaddr32(dd, regoffs, &limit);
346 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) {
347 ret = -EINVAL;
348 goto bail;
349 }
350 if (count >= limit)
351 count = limit;
352 reg_end = reg_addr + (count / sizeof(u64));
353
354
355 while (reg_addr < reg_end) {
356 u64 data = readq(reg_addr);
357
358 if (copy_to_user(uaddr, &data, sizeof(u64))) {
359 ret = -EFAULT;
360 goto bail;
361 }
362 reg_addr++;
363 uaddr += sizeof(u64);
364 }
365 ret = 0;
366bail:
367 return ret;
368}
369
370
371
372
373
374
375
376
377
378
379
380
381static int qib_write_umem64(struct qib_devdata *dd, u32 regoffs,
382 const void __user *uaddr, size_t count)
383{
384 u64 __iomem *reg_addr;
385 const u64 __iomem *reg_end;
386 u32 limit;
387 int ret;
388
389 reg_addr = (u64 __iomem *)qib_remap_ioaddr32(dd, regoffs, &limit);
390 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) {
391 ret = -EINVAL;
392 goto bail;
393 }
394 if (count >= limit)
395 count = limit;
396 reg_end = reg_addr + (count / sizeof(u64));
397
398
399 while (reg_addr < reg_end) {
400 u64 data;
401 if (copy_from_user(&data, uaddr, sizeof(data))) {
402 ret = -EFAULT;
403 goto bail;
404 }
405 writeq(data, reg_addr);
406
407 reg_addr++;
408 uaddr += sizeof(u64);
409 }
410 ret = 0;
411bail:
412 return ret;
413}
414
415
416
417
418
419
420
421
422
423
424
425static int qib_read_umem32(struct qib_devdata *dd, void __user *uaddr,
426 u32 regoffs, size_t count)
427{
428 const u32 __iomem *reg_addr;
429 const u32 __iomem *reg_end;
430 u32 limit;
431 int ret;
432
433 reg_addr = qib_remap_ioaddr32(dd, regoffs, &limit);
434 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) {
435 ret = -EINVAL;
436 goto bail;
437 }
438 if (count >= limit)
439 count = limit;
440 reg_end = reg_addr + (count / sizeof(u32));
441
442
443 while (reg_addr < reg_end) {
444 u32 data = readl(reg_addr);
445
446 if (copy_to_user(uaddr, &data, sizeof(data))) {
447 ret = -EFAULT;
448 goto bail;
449 }
450
451 reg_addr++;
452 uaddr += sizeof(u32);
453
454 }
455 ret = 0;
456bail:
457 return ret;
458}
459
460
461
462
463
464
465
466
467
468
469
470
471static int qib_write_umem32(struct qib_devdata *dd, u32 regoffs,
472 const void __user *uaddr, size_t count)
473{
474 u32 __iomem *reg_addr;
475 const u32 __iomem *reg_end;
476 u32 limit;
477 int ret;
478
479 reg_addr = qib_remap_ioaddr32(dd, regoffs, &limit);
480 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) {
481 ret = -EINVAL;
482 goto bail;
483 }
484 if (count >= limit)
485 count = limit;
486 reg_end = reg_addr + (count / sizeof(u32));
487
488 while (reg_addr < reg_end) {
489 u32 data;
490
491 if (copy_from_user(&data, uaddr, sizeof(data))) {
492 ret = -EFAULT;
493 goto bail;
494 }
495 writel(data, reg_addr);
496
497 reg_addr++;
498 uaddr += sizeof(u32);
499 }
500 ret = 0;
501bail:
502 return ret;
503}
504
505static int qib_diag_open(struct inode *in, struct file *fp)
506{
507 int unit = iminor(in) - QIB_DIAG_MINOR_BASE;
508 struct qib_devdata *dd;
509 struct qib_diag_client *dc;
510 int ret;
511
512 mutex_lock(&qib_mutex);
513
514 dd = qib_lookup(unit);
515
516 if (dd == NULL || !(dd->flags & QIB_PRESENT) ||
517 !dd->kregbase) {
518 ret = -ENODEV;
519 goto bail;
520 }
521
522 dc = get_client(dd);
523 if (!dc) {
524 ret = -ENOMEM;
525 goto bail;
526 }
527 dc->next = dd->diag_client;
528 dd->diag_client = dc;
529 fp->private_data = dc;
530 ret = 0;
531bail:
532 mutex_unlock(&qib_mutex);
533
534 return ret;
535}
536
537
538
539
540
541
542
543
544static ssize_t qib_diagpkt_write(struct file *fp,
545 const char __user *data,
546 size_t count, loff_t *off)
547{
548 u32 __iomem *piobuf;
549 u32 plen, clen, pbufn;
550 struct qib_diag_xpkt dp;
551 u32 *tmpbuf = NULL;
552 struct qib_devdata *dd;
553 struct qib_pportdata *ppd;
554 ssize_t ret = 0;
555
556 if (count != sizeof(dp)) {
557 ret = -EINVAL;
558 goto bail;
559 }
560 if (copy_from_user(&dp, data, sizeof(dp))) {
561 ret = -EFAULT;
562 goto bail;
563 }
564
565 dd = qib_lookup(dp.unit);
566 if (!dd || !(dd->flags & QIB_PRESENT) || !dd->kregbase) {
567 ret = -ENODEV;
568 goto bail;
569 }
570 if (!(dd->flags & QIB_INITTED)) {
571
572 ret = -ENODEV;
573 goto bail;
574 }
575
576 if (dp.version != _DIAG_XPKT_VERS) {
577 qib_dev_err(dd, "Invalid version %u for diagpkt_write\n",
578 dp.version);
579 ret = -EINVAL;
580 goto bail;
581 }
582
583 if (dp.len & 3) {
584 ret = -EINVAL;
585 goto bail;
586 }
587 if (!dp.port || dp.port > dd->num_pports) {
588 ret = -EINVAL;
589 goto bail;
590 }
591 ppd = &dd->pport[dp.port - 1];
592
593
594
595 plen = sizeof(u32) + dp.len;
596 clen = dp.len >> 2;
597
598 if ((plen + 4) > ppd->ibmaxlen) {
599 ret = -EINVAL;
600 goto bail;
601 }
602 tmpbuf = vmalloc(plen);
603 if (!tmpbuf) {
604 qib_devinfo(dd->pcidev,
605 "Unable to allocate tmp buffer, failing\n");
606 ret = -ENOMEM;
607 goto bail;
608 }
609
610 if (copy_from_user(tmpbuf,
611 (const void __user *) (unsigned long) dp.data,
612 dp.len)) {
613 ret = -EFAULT;
614 goto bail;
615 }
616
617 plen >>= 2;
618
619 if (dp.pbc_wd == 0)
620 dp.pbc_wd = plen;
621
622 piobuf = dd->f_getsendbuf(ppd, dp.pbc_wd, &pbufn);
623 if (!piobuf) {
624 ret = -EBUSY;
625 goto bail;
626 }
627
628 dd->f_sendctrl(dd->pport, QIB_SENDCTRL_DISARM_BUF(pbufn));
629
630
631 dd->f_txchk_change(dd, pbufn, 1, TXCHK_CHG_TYPE_DIS1, NULL);
632
633 writeq(dp.pbc_wd, piobuf);
634
635
636
637
638
639 if (dd->flags & QIB_PIO_FLUSH_WC) {
640 qib_flush_wc();
641 qib_pio_copy(piobuf + 2, tmpbuf, clen - 1);
642 qib_flush_wc();
643 __raw_writel(tmpbuf[clen - 1], piobuf + clen + 1);
644 } else
645 qib_pio_copy(piobuf + 2, tmpbuf, clen);
646
647 if (dd->flags & QIB_USE_SPCL_TRIG) {
648 u32 spcl_off = (pbufn >= dd->piobcnt2k) ? 2047 : 1023;
649
650 qib_flush_wc();
651 __raw_writel(0xaebecede, piobuf + spcl_off);
652 }
653
654
655
656
657
658
659 qib_flush_wc();
660 qib_sendbuf_done(dd, pbufn);
661 dd->f_txchk_change(dd, pbufn, 1, TXCHK_CHG_TYPE_ENAB1, NULL);
662
663 ret = sizeof(dp);
664
665bail:
666 vfree(tmpbuf);
667 return ret;
668}
669
670static int qib_diag_release(struct inode *in, struct file *fp)
671{
672 mutex_lock(&qib_mutex);
673 return_client(fp->private_data);
674 fp->private_data = NULL;
675 mutex_unlock(&qib_mutex);
676 return 0;
677}
678
679
680
681
682
683struct diag_observer_list_elt {
684 struct diag_observer_list_elt *next;
685 const struct diag_observer *op;
686};
687
688int qib_register_observer(struct qib_devdata *dd,
689 const struct diag_observer *op)
690{
691 struct diag_observer_list_elt *olp;
692 int ret = -EINVAL;
693
694 if (!dd || !op)
695 goto bail;
696 ret = -ENOMEM;
697 olp = vmalloc(sizeof *olp);
698 if (!olp) {
699 pr_err("vmalloc for observer failed\n");
700 goto bail;
701 }
702 if (olp) {
703 unsigned long flags;
704
705 spin_lock_irqsave(&dd->qib_diag_trans_lock, flags);
706 olp->op = op;
707 olp->next = dd->diag_observer_list;
708 dd->diag_observer_list = olp;
709 spin_unlock_irqrestore(&dd->qib_diag_trans_lock, flags);
710 ret = 0;
711 }
712bail:
713 return ret;
714}
715
716
717static void qib_unregister_observers(struct qib_devdata *dd)
718{
719 struct diag_observer_list_elt *olp;
720 unsigned long flags;
721
722 spin_lock_irqsave(&dd->qib_diag_trans_lock, flags);
723 olp = dd->diag_observer_list;
724 while (olp) {
725
726 dd->diag_observer_list = olp->next;
727 spin_unlock_irqrestore(&dd->qib_diag_trans_lock, flags);
728 vfree(olp);
729
730 spin_lock_irqsave(&dd->qib_diag_trans_lock, flags);
731 olp = dd->diag_observer_list;
732 }
733 spin_unlock_irqrestore(&dd->qib_diag_trans_lock, flags);
734}
735
736
737
738
739
740
741static const struct diag_observer *diag_get_observer(struct qib_devdata *dd,
742 u32 addr)
743{
744 struct diag_observer_list_elt *olp;
745 const struct diag_observer *op = NULL;
746
747 olp = dd->diag_observer_list;
748 while (olp) {
749 op = olp->op;
750 if (addr >= op->bottom && addr <= op->top)
751 break;
752 olp = olp->next;
753 }
754 if (!olp)
755 op = NULL;
756
757 return op;
758}
759
760static ssize_t qib_diag_read(struct file *fp, char __user *data,
761 size_t count, loff_t *off)
762{
763 struct qib_diag_client *dc = fp->private_data;
764 struct qib_devdata *dd = dc->dd;
765 void __iomem *kreg_base;
766 ssize_t ret;
767
768 if (dc->pid != current->pid) {
769 ret = -EPERM;
770 goto bail;
771 }
772
773 kreg_base = dd->kregbase;
774
775 if (count == 0)
776 ret = 0;
777 else if ((count % 4) || (*off % 4))
778
779 ret = -EINVAL;
780 else if (dc->state < READY && (*off || count != 8))
781 ret = -EINVAL;
782 else {
783 unsigned long flags;
784 u64 data64 = 0;
785 int use_32;
786 const struct diag_observer *op;
787
788 use_32 = (count % 8) || (*off % 8);
789 ret = -1;
790 spin_lock_irqsave(&dd->qib_diag_trans_lock, flags);
791
792
793
794
795
796 op = diag_get_observer(dd, *off);
797 if (op) {
798 u32 offset = *off;
799 ret = op->hook(dd, op, offset, &data64, 0, use_32);
800 }
801
802
803
804
805 spin_unlock_irqrestore(&dd->qib_diag_trans_lock, flags);
806 if (!op) {
807 if (use_32)
808
809
810
811
812 ret = qib_read_umem32(dd, data, (u32) *off,
813 count);
814 else
815 ret = qib_read_umem64(dd, data, (u32) *off,
816 count);
817 } else if (ret == count) {
818
819 ret = copy_to_user(data, &data64, use_32 ?
820 sizeof(u32) : sizeof(u64));
821 if (ret)
822 ret = -EFAULT;
823 }
824 }
825
826 if (ret >= 0) {
827 *off += count;
828 ret = count;
829 if (dc->state == OPENED)
830 dc->state = INIT;
831 }
832bail:
833 return ret;
834}
835
836static ssize_t qib_diag_write(struct file *fp, const char __user *data,
837 size_t count, loff_t *off)
838{
839 struct qib_diag_client *dc = fp->private_data;
840 struct qib_devdata *dd = dc->dd;
841 void __iomem *kreg_base;
842 ssize_t ret;
843
844 if (dc->pid != current->pid) {
845 ret = -EPERM;
846 goto bail;
847 }
848
849 kreg_base = dd->kregbase;
850
851 if (count == 0)
852 ret = 0;
853 else if ((count % 4) || (*off % 4))
854
855 ret = -EINVAL;
856 else if (dc->state < READY &&
857 ((*off || count != 8) || dc->state != INIT))
858
859 ret = -EINVAL;
860 else {
861 unsigned long flags;
862 const struct diag_observer *op = NULL;
863 int use_32 = (count % 8) || (*off % 8);
864
865
866
867
868
869
870
871
872
873 if (count == 4 || count == 8) {
874 u64 data64;
875 u32 offset = *off;
876 ret = copy_from_user(&data64, data, count);
877 if (ret) {
878 ret = -EFAULT;
879 goto bail;
880 }
881 spin_lock_irqsave(&dd->qib_diag_trans_lock, flags);
882 op = diag_get_observer(dd, *off);
883 if (op)
884 ret = op->hook(dd, op, offset, &data64, ~0Ull,
885 use_32);
886 spin_unlock_irqrestore(&dd->qib_diag_trans_lock, flags);
887 }
888
889 if (!op) {
890 if (use_32)
891
892
893
894
895 ret = qib_write_umem32(dd, (u32) *off, data,
896 count);
897 else
898 ret = qib_write_umem64(dd, (u32) *off, data,
899 count);
900 }
901 }
902
903 if (ret >= 0) {
904 *off += count;
905 ret = count;
906 if (dc->state == INIT)
907 dc->state = READY;
908 }
909bail:
910 return ret;
911}
912