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#include <rdma/ib_smi.h>
35#include <rdma/ib_pma.h>
36
37#include "ipath_kernel.h"
38#include "ipath_verbs.h"
39#include "ipath_common.h"
40
41#define IB_SMP_UNSUP_VERSION cpu_to_be16(0x0004)
42#define IB_SMP_UNSUP_METHOD cpu_to_be16(0x0008)
43#define IB_SMP_UNSUP_METH_ATTR cpu_to_be16(0x000C)
44#define IB_SMP_INVALID_FIELD cpu_to_be16(0x001C)
45
46static int reply(struct ib_smp *smp)
47{
48
49
50
51
52 smp->method = IB_MGMT_METHOD_GET_RESP;
53 if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
54 smp->status |= IB_SMP_DIRECTION;
55 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
56}
57
58static int recv_subn_get_nodedescription(struct ib_smp *smp,
59 struct ib_device *ibdev)
60{
61 if (smp->attr_mod)
62 smp->status |= IB_SMP_INVALID_FIELD;
63
64 memcpy(smp->data, ibdev->node_desc, sizeof(smp->data));
65
66 return reply(smp);
67}
68
69struct nodeinfo {
70 u8 base_version;
71 u8 class_version;
72 u8 node_type;
73 u8 num_ports;
74 __be64 sys_guid;
75 __be64 node_guid;
76 __be64 port_guid;
77 __be16 partition_cap;
78 __be16 device_id;
79 __be32 revision;
80 u8 local_port_num;
81 u8 vendor_id[3];
82} __attribute__ ((packed));
83
84static int recv_subn_get_nodeinfo(struct ib_smp *smp,
85 struct ib_device *ibdev, u8 port)
86{
87 struct nodeinfo *nip = (struct nodeinfo *)&smp->data;
88 struct ipath_devdata *dd = to_idev(ibdev)->dd;
89 u32 vendor, majrev, minrev;
90
91
92 if (smp->attr_mod || (dd->ipath_guid == 0))
93 smp->status |= IB_SMP_INVALID_FIELD;
94
95 nip->base_version = 1;
96 nip->class_version = 1;
97 nip->node_type = 1;
98
99
100
101
102
103 nip->num_ports = ibdev->phys_port_cnt;
104
105 nip->sys_guid = to_idev(ibdev)->sys_image_guid;
106 nip->node_guid = dd->ipath_guid;
107 nip->port_guid = dd->ipath_guid;
108 nip->partition_cap = cpu_to_be16(ipath_get_npkeys(dd));
109 nip->device_id = cpu_to_be16(dd->ipath_deviceid);
110 majrev = dd->ipath_majrev;
111 minrev = dd->ipath_minrev;
112 nip->revision = cpu_to_be32((majrev << 16) | minrev);
113 nip->local_port_num = port;
114 vendor = dd->ipath_vendorid;
115 nip->vendor_id[0] = IPATH_SRC_OUI_1;
116 nip->vendor_id[1] = IPATH_SRC_OUI_2;
117 nip->vendor_id[2] = IPATH_SRC_OUI_3;
118
119 return reply(smp);
120}
121
122static int recv_subn_get_guidinfo(struct ib_smp *smp,
123 struct ib_device *ibdev)
124{
125 u32 startgx = 8 * be32_to_cpu(smp->attr_mod);
126 __be64 *p = (__be64 *) smp->data;
127
128
129
130 memset(smp->data, 0, sizeof(smp->data));
131
132
133
134
135
136 if (startgx == 0) {
137 __be64 g = to_idev(ibdev)->dd->ipath_guid;
138 if (g == 0)
139
140 smp->status |= IB_SMP_INVALID_FIELD;
141 else
142
143 *p = g;
144 } else
145 smp->status |= IB_SMP_INVALID_FIELD;
146
147 return reply(smp);
148}
149
150static void set_link_width_enabled(struct ipath_devdata *dd, u32 w)
151{
152 (void) dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_LWID_ENB, w);
153}
154
155static void set_link_speed_enabled(struct ipath_devdata *dd, u32 s)
156{
157 (void) dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_SPD_ENB, s);
158}
159
160static int get_overrunthreshold(struct ipath_devdata *dd)
161{
162 return (dd->ipath_ibcctrl >>
163 INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT) &
164 INFINIPATH_IBCC_OVERRUNTHRESHOLD_MASK;
165}
166
167
168
169
170
171
172
173
174static int set_overrunthreshold(struct ipath_devdata *dd, unsigned n)
175{
176 unsigned v;
177
178 v = (dd->ipath_ibcctrl >> INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT) &
179 INFINIPATH_IBCC_OVERRUNTHRESHOLD_MASK;
180 if (v != n) {
181 dd->ipath_ibcctrl &=
182 ~(INFINIPATH_IBCC_OVERRUNTHRESHOLD_MASK <<
183 INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT);
184 dd->ipath_ibcctrl |=
185 (u64) n << INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT;
186 ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
187 dd->ipath_ibcctrl);
188 }
189 return 0;
190}
191
192static int get_phyerrthreshold(struct ipath_devdata *dd)
193{
194 return (dd->ipath_ibcctrl >>
195 INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT) &
196 INFINIPATH_IBCC_PHYERRTHRESHOLD_MASK;
197}
198
199
200
201
202
203
204
205
206static int set_phyerrthreshold(struct ipath_devdata *dd, unsigned n)
207{
208 unsigned v;
209
210 v = (dd->ipath_ibcctrl >> INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT) &
211 INFINIPATH_IBCC_PHYERRTHRESHOLD_MASK;
212 if (v != n) {
213 dd->ipath_ibcctrl &=
214 ~(INFINIPATH_IBCC_PHYERRTHRESHOLD_MASK <<
215 INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT);
216 dd->ipath_ibcctrl |=
217 (u64) n << INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT;
218 ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
219 dd->ipath_ibcctrl);
220 }
221 return 0;
222}
223
224
225
226
227
228
229
230static int get_linkdowndefaultstate(struct ipath_devdata *dd)
231{
232 return !!(dd->ipath_ibcctrl & INFINIPATH_IBCC_LINKDOWNDEFAULTSTATE);
233}
234
235static int recv_subn_get_portinfo(struct ib_smp *smp,
236 struct ib_device *ibdev, u8 port)
237{
238 struct ipath_ibdev *dev;
239 struct ipath_devdata *dd;
240 struct ib_port_info *pip = (struct ib_port_info *)smp->data;
241 u16 lid;
242 u8 ibcstat;
243 u8 mtu;
244 int ret;
245
246 if (be32_to_cpu(smp->attr_mod) > ibdev->phys_port_cnt) {
247 smp->status |= IB_SMP_INVALID_FIELD;
248 ret = reply(smp);
249 goto bail;
250 }
251
252 dev = to_idev(ibdev);
253 dd = dev->dd;
254
255
256 memset(smp->data, 0, sizeof(smp->data));
257
258
259 if (smp->method == IB_MGMT_METHOD_SET || dev->mkey == smp->mkey ||
260 dev->mkeyprot == 0)
261 pip->mkey = dev->mkey;
262 pip->gid_prefix = dev->gid_prefix;
263 lid = dd->ipath_lid;
264 pip->lid = lid ? cpu_to_be16(lid) : IB_LID_PERMISSIVE;
265 pip->sm_lid = cpu_to_be16(dev->sm_lid);
266 pip->cap_mask = cpu_to_be32(dev->port_cap_flags);
267
268 pip->mkey_lease_period = cpu_to_be16(dev->mkey_lease_period);
269 pip->local_port_num = port;
270 pip->link_width_enabled = dd->ipath_link_width_enabled;
271 pip->link_width_supported = dd->ipath_link_width_supported;
272 pip->link_width_active = dd->ipath_link_width_active;
273 pip->linkspeed_portstate = dd->ipath_link_speed_supported << 4;
274 ibcstat = dd->ipath_lastibcstat;
275
276 pip->linkspeed_portstate |= ipath_ib_linkstate(dd, ibcstat) + 1;
277
278 pip->portphysstate_linkdown =
279 (ipath_cvt_physportstate[ibcstat & dd->ibcs_lts_mask] << 4) |
280 (get_linkdowndefaultstate(dd) ? 1 : 2);
281 pip->mkeyprot_resv_lmc = (dev->mkeyprot << 6) | dd->ipath_lmc;
282 pip->linkspeedactive_enabled = (dd->ipath_link_speed_active << 4) |
283 dd->ipath_link_speed_enabled;
284 switch (dd->ipath_ibmtu) {
285 case 4096:
286 mtu = IB_MTU_4096;
287 break;
288 case 2048:
289 mtu = IB_MTU_2048;
290 break;
291 case 1024:
292 mtu = IB_MTU_1024;
293 break;
294 case 512:
295 mtu = IB_MTU_512;
296 break;
297 case 256:
298 mtu = IB_MTU_256;
299 break;
300 default:
301 mtu = IB_MTU_2048;
302 break;
303 }
304 pip->neighbormtu_mastersmsl = (mtu << 4) | dev->sm_sl;
305 pip->vlcap_inittype = 0x10;
306 pip->vl_high_limit = dev->vl_high_limit;
307
308
309
310
311 pip->inittypereply_mtucap = ipath_mtu4096 ? IB_MTU_4096 : IB_MTU_2048;
312
313
314 pip->operationalvl_pei_peo_fpi_fpo = 0x10;
315 pip->mkey_violations = cpu_to_be16(dev->mkey_violations);
316
317 pip->pkey_violations =
318 cpu_to_be16((ipath_get_cr_errpkey(dd) -
319 dev->z_pkey_violations) & 0xFFFF);
320 pip->qkey_violations = cpu_to_be16(dev->qkey_violations);
321
322 pip->guid_cap = 1;
323 pip->clientrereg_resv_subnetto = dev->subnet_timeout;
324
325 pip->resv_resptimevalue = 3;
326 pip->localphyerrors_overrunerrors =
327 (get_phyerrthreshold(dd) << 4) |
328 get_overrunthreshold(dd);
329
330 if (dev->port_cap_flags & IB_PORT_LINK_LATENCY_SUP) {
331 u32 v;
332
333 v = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LINKLATENCY);
334 pip->link_roundtrip_latency[0] = v >> 16;
335 pip->link_roundtrip_latency[1] = v >> 8;
336 pip->link_roundtrip_latency[2] = v;
337 }
338
339 ret = reply(smp);
340
341bail:
342 return ret;
343}
344
345
346
347
348
349
350static int get_pkeys(struct ipath_devdata *dd, u16 * pkeys)
351{
352
353 struct ipath_portdata *pd = dd->ipath_pd[0];
354
355 memcpy(pkeys, pd->port_pkeys, sizeof(pd->port_pkeys));
356
357 return 0;
358}
359
360static int recv_subn_get_pkeytable(struct ib_smp *smp,
361 struct ib_device *ibdev)
362{
363 u32 startpx = 32 * (be32_to_cpu(smp->attr_mod) & 0xffff);
364 u16 *p = (u16 *) smp->data;
365 __be16 *q = (__be16 *) smp->data;
366
367
368
369 memset(smp->data, 0, sizeof(smp->data));
370 if (startpx == 0) {
371 struct ipath_ibdev *dev = to_idev(ibdev);
372 unsigned i, n = ipath_get_npkeys(dev->dd);
373
374 get_pkeys(dev->dd, p);
375
376 for (i = 0; i < n; i++)
377 q[i] = cpu_to_be16(p[i]);
378 } else
379 smp->status |= IB_SMP_INVALID_FIELD;
380
381 return reply(smp);
382}
383
384static int recv_subn_set_guidinfo(struct ib_smp *smp,
385 struct ib_device *ibdev)
386{
387
388 return recv_subn_get_guidinfo(smp, ibdev);
389}
390
391
392
393
394
395
396
397
398static int set_linkdowndefaultstate(struct ipath_devdata *dd, int sleep)
399{
400 if (sleep)
401 dd->ipath_ibcctrl |= INFINIPATH_IBCC_LINKDOWNDEFAULTSTATE;
402 else
403 dd->ipath_ibcctrl &= ~INFINIPATH_IBCC_LINKDOWNDEFAULTSTATE;
404 ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
405 dd->ipath_ibcctrl);
406 return 0;
407}
408
409
410
411
412
413
414
415
416
417static int recv_subn_set_portinfo(struct ib_smp *smp,
418 struct ib_device *ibdev, u8 port)
419{
420 struct ib_port_info *pip = (struct ib_port_info *)smp->data;
421 struct ib_event event;
422 struct ipath_ibdev *dev;
423 struct ipath_devdata *dd;
424 char clientrereg = 0;
425 u16 lid, smlid;
426 u8 lwe;
427 u8 lse;
428 u8 state;
429 u16 lstate;
430 u32 mtu;
431 int ret, ore;
432
433 if (be32_to_cpu(smp->attr_mod) > ibdev->phys_port_cnt)
434 goto err;
435
436 dev = to_idev(ibdev);
437 dd = dev->dd;
438 event.device = ibdev;
439 event.element.port_num = port;
440
441 dev->mkey = pip->mkey;
442 dev->gid_prefix = pip->gid_prefix;
443 dev->mkey_lease_period = be16_to_cpu(pip->mkey_lease_period);
444
445 lid = be16_to_cpu(pip->lid);
446 if (dd->ipath_lid != lid ||
447 dd->ipath_lmc != (pip->mkeyprot_resv_lmc & 7)) {
448
449 if (lid == 0 || lid >= IPATH_MULTICAST_LID_BASE)
450 goto err;
451 ipath_set_lid(dd, lid, pip->mkeyprot_resv_lmc & 7);
452 event.event = IB_EVENT_LID_CHANGE;
453 ib_dispatch_event(&event);
454 }
455
456 smlid = be16_to_cpu(pip->sm_lid);
457 if (smlid != dev->sm_lid) {
458
459 if (smlid == 0 || smlid >= IPATH_MULTICAST_LID_BASE)
460 goto err;
461 dev->sm_lid = smlid;
462 event.event = IB_EVENT_SM_CHANGE;
463 ib_dispatch_event(&event);
464 }
465
466
467 lwe = pip->link_width_enabled;
468 if (lwe) {
469 if (lwe == 0xFF)
470 lwe = dd->ipath_link_width_supported;
471 else if (lwe >= 16 || (lwe & ~dd->ipath_link_width_supported))
472 goto err;
473 set_link_width_enabled(dd, lwe);
474 }
475
476
477 lse = pip->linkspeedactive_enabled & 0xF;
478 if (lse) {
479 if (lse == 15)
480 lse = dd->ipath_link_speed_supported;
481 else if (lse >= 8 || (lse & ~dd->ipath_link_speed_supported))
482 goto err;
483 set_link_speed_enabled(dd, lse);
484 }
485
486
487 switch (pip->portphysstate_linkdown & 0xF) {
488 case 0:
489 break;
490 case 1:
491 if (set_linkdowndefaultstate(dd, 1))
492 goto err;
493 break;
494 case 2:
495 if (set_linkdowndefaultstate(dd, 0))
496 goto err;
497 break;
498 default:
499 goto err;
500 }
501
502 dev->mkeyprot = pip->mkeyprot_resv_lmc >> 6;
503 dev->vl_high_limit = pip->vl_high_limit;
504
505 switch ((pip->neighbormtu_mastersmsl >> 4) & 0xF) {
506 case IB_MTU_256:
507 mtu = 256;
508 break;
509 case IB_MTU_512:
510 mtu = 512;
511 break;
512 case IB_MTU_1024:
513 mtu = 1024;
514 break;
515 case IB_MTU_2048:
516 mtu = 2048;
517 break;
518 case IB_MTU_4096:
519 if (!ipath_mtu4096)
520 goto err;
521 mtu = 4096;
522 break;
523 default:
524
525 goto err;
526 }
527 ipath_set_mtu(dd, mtu);
528
529 dev->sm_sl = pip->neighbormtu_mastersmsl & 0xF;
530
531
532 if (((pip->operationalvl_pei_peo_fpi_fpo >> 4) & 0xF) > 1)
533 goto err;
534
535 if (pip->mkey_violations == 0)
536 dev->mkey_violations = 0;
537
538
539
540
541
542 if (pip->pkey_violations == 0)
543 dev->z_pkey_violations = ipath_get_cr_errpkey(dd);
544
545 if (pip->qkey_violations == 0)
546 dev->qkey_violations = 0;
547
548 ore = pip->localphyerrors_overrunerrors;
549 if (set_phyerrthreshold(dd, (ore >> 4) & 0xF))
550 goto err;
551
552 if (set_overrunthreshold(dd, (ore & 0xF)))
553 goto err;
554
555 dev->subnet_timeout = pip->clientrereg_resv_subnetto & 0x1F;
556
557 if (pip->clientrereg_resv_subnetto & 0x80) {
558 clientrereg = 1;
559 event.event = IB_EVENT_CLIENT_REREGISTER;
560 ib_dispatch_event(&event);
561 }
562
563
564
565
566
567
568
569 state = pip->linkspeed_portstate & 0xF;
570 lstate = (pip->portphysstate_linkdown >> 4) & 0xF;
571 if (lstate && !(state == IB_PORT_DOWN || state == IB_PORT_NOP))
572 goto err;
573
574
575
576
577
578 switch (state) {
579 case IB_PORT_NOP:
580 if (lstate == 0)
581 break;
582
583 case IB_PORT_DOWN:
584 if (lstate == 0)
585 lstate = IPATH_IB_LINKDOWN_ONLY;
586 else if (lstate == 1)
587 lstate = IPATH_IB_LINKDOWN_SLEEP;
588 else if (lstate == 2)
589 lstate = IPATH_IB_LINKDOWN;
590 else if (lstate == 3)
591 lstate = IPATH_IB_LINKDOWN_DISABLE;
592 else
593 goto err;
594 ipath_set_linkstate(dd, lstate);
595 if (lstate == IPATH_IB_LINKDOWN_DISABLE) {
596 ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
597 goto done;
598 }
599 ipath_wait_linkstate(dd, IPATH_LINKINIT | IPATH_LINKARMED |
600 IPATH_LINKACTIVE, 1000);
601 break;
602 case IB_PORT_ARMED:
603 ipath_set_linkstate(dd, IPATH_IB_LINKARM);
604 break;
605 case IB_PORT_ACTIVE:
606 ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
607 break;
608 default:
609
610 goto err;
611 }
612
613 ret = recv_subn_get_portinfo(smp, ibdev, port);
614
615 if (clientrereg)
616 pip->clientrereg_resv_subnetto |= 0x80;
617
618 goto done;
619
620err:
621 smp->status |= IB_SMP_INVALID_FIELD;
622 ret = recv_subn_get_portinfo(smp, ibdev, port);
623
624done:
625 return ret;
626}
627
628
629
630
631
632
633
634
635
636static int rm_pkey(struct ipath_devdata *dd, u16 key)
637{
638 int i;
639 int ret;
640
641 for (i = 0; i < ARRAY_SIZE(dd->ipath_pkeys); i++) {
642 if (dd->ipath_pkeys[i] != key)
643 continue;
644 if (atomic_dec_and_test(&dd->ipath_pkeyrefs[i])) {
645 dd->ipath_pkeys[i] = 0;
646 ret = 1;
647 goto bail;
648 }
649 break;
650 }
651
652 ret = 0;
653
654bail:
655 return ret;
656}
657
658
659
660
661
662
663
664
665
666static int add_pkey(struct ipath_devdata *dd, u16 key)
667{
668 int i;
669 u16 lkey = key & 0x7FFF;
670 int any = 0;
671 int ret;
672
673 if (lkey == 0x7FFF) {
674 ret = 0;
675 goto bail;
676 }
677
678
679 for (i = 0; i < ARRAY_SIZE(dd->ipath_pkeys); i++) {
680 if (!dd->ipath_pkeys[i]) {
681 any++;
682 continue;
683 }
684
685 if (dd->ipath_pkeys[i] == key) {
686 if (atomic_inc_return(&dd->ipath_pkeyrefs[i]) > 1) {
687 ret = 0;
688 goto bail;
689 }
690
691 atomic_dec(&dd->ipath_pkeyrefs[i]);
692 any++;
693 }
694
695
696
697
698
699 if ((dd->ipath_pkeys[i] & 0x7FFF) == lkey) {
700 ret = -EEXIST;
701 goto bail;
702 }
703 }
704 if (!any) {
705 ret = -EBUSY;
706 goto bail;
707 }
708 for (i = 0; i < ARRAY_SIZE(dd->ipath_pkeys); i++) {
709 if (!dd->ipath_pkeys[i] &&
710 atomic_inc_return(&dd->ipath_pkeyrefs[i]) == 1) {
711
712 ipath_stats.sps_pkeys[i] = lkey;
713 dd->ipath_pkeys[i] = key;
714 ret = 1;
715 goto bail;
716 }
717 }
718 ret = -EBUSY;
719
720bail:
721 return ret;
722}
723
724
725
726
727
728
729static int set_pkeys(struct ipath_devdata *dd, u16 *pkeys)
730{
731 struct ipath_portdata *pd;
732 int i;
733 int changed = 0;
734
735
736 pd = dd->ipath_pd[0];
737
738 for (i = 0; i < ARRAY_SIZE(pd->port_pkeys); i++) {
739 u16 key = pkeys[i];
740 u16 okey = pd->port_pkeys[i];
741
742 if (key == okey)
743 continue;
744
745
746
747
748 if (okey & 0x7FFF)
749 changed |= rm_pkey(dd, okey);
750 if (key & 0x7FFF) {
751 int ret = add_pkey(dd, key);
752
753 if (ret < 0)
754 key = 0;
755 else
756 changed |= ret;
757 }
758 pd->port_pkeys[i] = key;
759 }
760 if (changed) {
761 u64 pkey;
762
763 pkey = (u64) dd->ipath_pkeys[0] |
764 ((u64) dd->ipath_pkeys[1] << 16) |
765 ((u64) dd->ipath_pkeys[2] << 32) |
766 ((u64) dd->ipath_pkeys[3] << 48);
767 ipath_cdbg(VERBOSE, "p0 new pkey reg %llx\n",
768 (unsigned long long) pkey);
769 ipath_write_kreg(dd, dd->ipath_kregs->kr_partitionkey,
770 pkey);
771 }
772 return 0;
773}
774
775static int recv_subn_set_pkeytable(struct ib_smp *smp,
776 struct ib_device *ibdev)
777{
778 u32 startpx = 32 * (be32_to_cpu(smp->attr_mod) & 0xffff);
779 __be16 *p = (__be16 *) smp->data;
780 u16 *q = (u16 *) smp->data;
781 struct ipath_ibdev *dev = to_idev(ibdev);
782 unsigned i, n = ipath_get_npkeys(dev->dd);
783
784 for (i = 0; i < n; i++)
785 q[i] = be16_to_cpu(p[i]);
786
787 if (startpx != 0 || set_pkeys(dev->dd, q) != 0)
788 smp->status |= IB_SMP_INVALID_FIELD;
789
790 return recv_subn_get_pkeytable(smp, ibdev);
791}
792
793static int recv_pma_get_classportinfo(struct ib_pma_mad *pmp)
794{
795 struct ib_class_port_info *p =
796 (struct ib_class_port_info *)pmp->data;
797
798 memset(pmp->data, 0, sizeof(pmp->data));
799
800 if (pmp->mad_hdr.attr_mod != 0)
801 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
802
803
804 p->capability_mask = cpu_to_be16(1 << 8);
805 p->base_version = 1;
806 p->class_version = 1;
807
808
809
810
811 p->resp_time_value = 18;
812
813 return reply((struct ib_smp *) pmp);
814}
815
816
817
818
819
820
821#define COUNTER_MASK(q, n) (q << ((9 - n) * 3))
822#define COUNTER_MASK0_9 cpu_to_be32(COUNTER_MASK(1, 0) | \
823 COUNTER_MASK(1, 1) | \
824 COUNTER_MASK(1, 2) | \
825 COUNTER_MASK(1, 3) | \
826 COUNTER_MASK(1, 4))
827
828static int recv_pma_get_portsamplescontrol(struct ib_pma_mad *pmp,
829 struct ib_device *ibdev, u8 port)
830{
831 struct ib_pma_portsamplescontrol *p =
832 (struct ib_pma_portsamplescontrol *)pmp->data;
833 struct ipath_ibdev *dev = to_idev(ibdev);
834 struct ipath_cregs const *crp = dev->dd->ipath_cregs;
835 unsigned long flags;
836 u8 port_select = p->port_select;
837
838 memset(pmp->data, 0, sizeof(pmp->data));
839
840 p->port_select = port_select;
841 if (pmp->mad_hdr.attr_mod != 0 ||
842 (port_select != port && port_select != 0xFF))
843 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
844
845
846
847
848
849
850
851
852
853 if (crp->cr_psstat)
854 p->tick = dev->dd->ipath_link_speed_active - 1;
855 else
856 p->tick = 250;
857 p->counter_width = 4;
858 p->counter_mask0_9 = COUNTER_MASK0_9;
859 spin_lock_irqsave(&dev->pending_lock, flags);
860 if (crp->cr_psstat)
861 p->sample_status = ipath_read_creg32(dev->dd, crp->cr_psstat);
862 else
863 p->sample_status = dev->pma_sample_status;
864 p->sample_start = cpu_to_be32(dev->pma_sample_start);
865 p->sample_interval = cpu_to_be32(dev->pma_sample_interval);
866 p->tag = cpu_to_be16(dev->pma_tag);
867 p->counter_select[0] = dev->pma_counter_select[0];
868 p->counter_select[1] = dev->pma_counter_select[1];
869 p->counter_select[2] = dev->pma_counter_select[2];
870 p->counter_select[3] = dev->pma_counter_select[3];
871 p->counter_select[4] = dev->pma_counter_select[4];
872 spin_unlock_irqrestore(&dev->pending_lock, flags);
873
874 return reply((struct ib_smp *) pmp);
875}
876
877static int recv_pma_set_portsamplescontrol(struct ib_pma_mad *pmp,
878 struct ib_device *ibdev, u8 port)
879{
880 struct ib_pma_portsamplescontrol *p =
881 (struct ib_pma_portsamplescontrol *)pmp->data;
882 struct ipath_ibdev *dev = to_idev(ibdev);
883 struct ipath_cregs const *crp = dev->dd->ipath_cregs;
884 unsigned long flags;
885 u8 status;
886 int ret;
887
888 if (pmp->mad_hdr.attr_mod != 0 ||
889 (p->port_select != port && p->port_select != 0xFF)) {
890 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
891 ret = reply((struct ib_smp *) pmp);
892 goto bail;
893 }
894
895 spin_lock_irqsave(&dev->pending_lock, flags);
896 if (crp->cr_psstat)
897 status = ipath_read_creg32(dev->dd, crp->cr_psstat);
898 else
899 status = dev->pma_sample_status;
900 if (status == IB_PMA_SAMPLE_STATUS_DONE) {
901 dev->pma_sample_start = be32_to_cpu(p->sample_start);
902 dev->pma_sample_interval = be32_to_cpu(p->sample_interval);
903 dev->pma_tag = be16_to_cpu(p->tag);
904 dev->pma_counter_select[0] = p->counter_select[0];
905 dev->pma_counter_select[1] = p->counter_select[1];
906 dev->pma_counter_select[2] = p->counter_select[2];
907 dev->pma_counter_select[3] = p->counter_select[3];
908 dev->pma_counter_select[4] = p->counter_select[4];
909 if (crp->cr_psstat) {
910 ipath_write_creg(dev->dd, crp->cr_psinterval,
911 dev->pma_sample_interval);
912 ipath_write_creg(dev->dd, crp->cr_psstart,
913 dev->pma_sample_start);
914 } else
915 dev->pma_sample_status = IB_PMA_SAMPLE_STATUS_STARTED;
916 }
917 spin_unlock_irqrestore(&dev->pending_lock, flags);
918
919 ret = recv_pma_get_portsamplescontrol(pmp, ibdev, port);
920
921bail:
922 return ret;
923}
924
925static u64 get_counter(struct ipath_ibdev *dev,
926 struct ipath_cregs const *crp,
927 __be16 sel)
928{
929 u64 ret;
930
931 switch (sel) {
932 case IB_PMA_PORT_XMIT_DATA:
933 ret = (crp->cr_psxmitdatacount) ?
934 ipath_read_creg32(dev->dd, crp->cr_psxmitdatacount) :
935 dev->ipath_sword;
936 break;
937 case IB_PMA_PORT_RCV_DATA:
938 ret = (crp->cr_psrcvdatacount) ?
939 ipath_read_creg32(dev->dd, crp->cr_psrcvdatacount) :
940 dev->ipath_rword;
941 break;
942 case IB_PMA_PORT_XMIT_PKTS:
943 ret = (crp->cr_psxmitpktscount) ?
944 ipath_read_creg32(dev->dd, crp->cr_psxmitpktscount) :
945 dev->ipath_spkts;
946 break;
947 case IB_PMA_PORT_RCV_PKTS:
948 ret = (crp->cr_psrcvpktscount) ?
949 ipath_read_creg32(dev->dd, crp->cr_psrcvpktscount) :
950 dev->ipath_rpkts;
951 break;
952 case IB_PMA_PORT_XMIT_WAIT:
953 ret = (crp->cr_psxmitwaitcount) ?
954 ipath_read_creg32(dev->dd, crp->cr_psxmitwaitcount) :
955 dev->ipath_xmit_wait;
956 break;
957 default:
958 ret = 0;
959 }
960
961 return ret;
962}
963
964static int recv_pma_get_portsamplesresult(struct ib_pma_mad *pmp,
965 struct ib_device *ibdev)
966{
967 struct ib_pma_portsamplesresult *p =
968 (struct ib_pma_portsamplesresult *)pmp->data;
969 struct ipath_ibdev *dev = to_idev(ibdev);
970 struct ipath_cregs const *crp = dev->dd->ipath_cregs;
971 u8 status;
972 int i;
973
974 memset(pmp->data, 0, sizeof(pmp->data));
975 p->tag = cpu_to_be16(dev->pma_tag);
976 if (crp->cr_psstat)
977 status = ipath_read_creg32(dev->dd, crp->cr_psstat);
978 else
979 status = dev->pma_sample_status;
980 p->sample_status = cpu_to_be16(status);
981 for (i = 0; i < ARRAY_SIZE(dev->pma_counter_select); i++)
982 p->counter[i] = (status != IB_PMA_SAMPLE_STATUS_DONE) ? 0 :
983 cpu_to_be32(
984 get_counter(dev, crp, dev->pma_counter_select[i]));
985
986 return reply((struct ib_smp *) pmp);
987}
988
989static int recv_pma_get_portsamplesresult_ext(struct ib_pma_mad *pmp,
990 struct ib_device *ibdev)
991{
992 struct ib_pma_portsamplesresult_ext *p =
993 (struct ib_pma_portsamplesresult_ext *)pmp->data;
994 struct ipath_ibdev *dev = to_idev(ibdev);
995 struct ipath_cregs const *crp = dev->dd->ipath_cregs;
996 u8 status;
997 int i;
998
999 memset(pmp->data, 0, sizeof(pmp->data));
1000 p->tag = cpu_to_be16(dev->pma_tag);
1001 if (crp->cr_psstat)
1002 status = ipath_read_creg32(dev->dd, crp->cr_psstat);
1003 else
1004 status = dev->pma_sample_status;
1005 p->sample_status = cpu_to_be16(status);
1006
1007 p->extended_width = cpu_to_be32(0x80000000);
1008 for (i = 0; i < ARRAY_SIZE(dev->pma_counter_select); i++)
1009 p->counter[i] = (status != IB_PMA_SAMPLE_STATUS_DONE) ? 0 :
1010 cpu_to_be64(
1011 get_counter(dev, crp, dev->pma_counter_select[i]));
1012
1013 return reply((struct ib_smp *) pmp);
1014}
1015
1016static int recv_pma_get_portcounters(struct ib_pma_mad *pmp,
1017 struct ib_device *ibdev, u8 port)
1018{
1019 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
1020 pmp->data;
1021 struct ipath_ibdev *dev = to_idev(ibdev);
1022 struct ipath_verbs_counters cntrs;
1023 u8 port_select = p->port_select;
1024
1025 ipath_get_counters(dev->dd, &cntrs);
1026
1027
1028 cntrs.symbol_error_counter -= dev->z_symbol_error_counter;
1029 cntrs.link_error_recovery_counter -=
1030 dev->z_link_error_recovery_counter;
1031 cntrs.link_downed_counter -= dev->z_link_downed_counter;
1032 cntrs.port_rcv_errors += dev->rcv_errors;
1033 cntrs.port_rcv_errors -= dev->z_port_rcv_errors;
1034 cntrs.port_rcv_remphys_errors -= dev->z_port_rcv_remphys_errors;
1035 cntrs.port_xmit_discards -= dev->z_port_xmit_discards;
1036 cntrs.port_xmit_data -= dev->z_port_xmit_data;
1037 cntrs.port_rcv_data -= dev->z_port_rcv_data;
1038 cntrs.port_xmit_packets -= dev->z_port_xmit_packets;
1039 cntrs.port_rcv_packets -= dev->z_port_rcv_packets;
1040 cntrs.local_link_integrity_errors -=
1041 dev->z_local_link_integrity_errors;
1042 cntrs.excessive_buffer_overrun_errors -=
1043 dev->z_excessive_buffer_overrun_errors;
1044 cntrs.vl15_dropped -= dev->z_vl15_dropped;
1045 cntrs.vl15_dropped += dev->n_vl15_dropped;
1046
1047 memset(pmp->data, 0, sizeof(pmp->data));
1048
1049 p->port_select = port_select;
1050 if (pmp->mad_hdr.attr_mod != 0 ||
1051 (port_select != port && port_select != 0xFF))
1052 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
1053
1054 if (cntrs.symbol_error_counter > 0xFFFFUL)
1055 p->symbol_error_counter = cpu_to_be16(0xFFFF);
1056 else
1057 p->symbol_error_counter =
1058 cpu_to_be16((u16)cntrs.symbol_error_counter);
1059 if (cntrs.link_error_recovery_counter > 0xFFUL)
1060 p->link_error_recovery_counter = 0xFF;
1061 else
1062 p->link_error_recovery_counter =
1063 (u8)cntrs.link_error_recovery_counter;
1064 if (cntrs.link_downed_counter > 0xFFUL)
1065 p->link_downed_counter = 0xFF;
1066 else
1067 p->link_downed_counter = (u8)cntrs.link_downed_counter;
1068 if (cntrs.port_rcv_errors > 0xFFFFUL)
1069 p->port_rcv_errors = cpu_to_be16(0xFFFF);
1070 else
1071 p->port_rcv_errors =
1072 cpu_to_be16((u16) cntrs.port_rcv_errors);
1073 if (cntrs.port_rcv_remphys_errors > 0xFFFFUL)
1074 p->port_rcv_remphys_errors = cpu_to_be16(0xFFFF);
1075 else
1076 p->port_rcv_remphys_errors =
1077 cpu_to_be16((u16)cntrs.port_rcv_remphys_errors);
1078 if (cntrs.port_xmit_discards > 0xFFFFUL)
1079 p->port_xmit_discards = cpu_to_be16(0xFFFF);
1080 else
1081 p->port_xmit_discards =
1082 cpu_to_be16((u16)cntrs.port_xmit_discards);
1083 if (cntrs.local_link_integrity_errors > 0xFUL)
1084 cntrs.local_link_integrity_errors = 0xFUL;
1085 if (cntrs.excessive_buffer_overrun_errors > 0xFUL)
1086 cntrs.excessive_buffer_overrun_errors = 0xFUL;
1087 p->link_overrun_errors = (cntrs.local_link_integrity_errors << 4) |
1088 cntrs.excessive_buffer_overrun_errors;
1089 if (cntrs.vl15_dropped > 0xFFFFUL)
1090 p->vl15_dropped = cpu_to_be16(0xFFFF);
1091 else
1092 p->vl15_dropped = cpu_to_be16((u16)cntrs.vl15_dropped);
1093 if (cntrs.port_xmit_data > 0xFFFFFFFFUL)
1094 p->port_xmit_data = cpu_to_be32(0xFFFFFFFF);
1095 else
1096 p->port_xmit_data = cpu_to_be32((u32)cntrs.port_xmit_data);
1097 if (cntrs.port_rcv_data > 0xFFFFFFFFUL)
1098 p->port_rcv_data = cpu_to_be32(0xFFFFFFFF);
1099 else
1100 p->port_rcv_data = cpu_to_be32((u32)cntrs.port_rcv_data);
1101 if (cntrs.port_xmit_packets > 0xFFFFFFFFUL)
1102 p->port_xmit_packets = cpu_to_be32(0xFFFFFFFF);
1103 else
1104 p->port_xmit_packets =
1105 cpu_to_be32((u32)cntrs.port_xmit_packets);
1106 if (cntrs.port_rcv_packets > 0xFFFFFFFFUL)
1107 p->port_rcv_packets = cpu_to_be32(0xFFFFFFFF);
1108 else
1109 p->port_rcv_packets =
1110 cpu_to_be32((u32) cntrs.port_rcv_packets);
1111
1112 return reply((struct ib_smp *) pmp);
1113}
1114
1115static int recv_pma_get_portcounters_ext(struct ib_pma_mad *pmp,
1116 struct ib_device *ibdev, u8 port)
1117{
1118 struct ib_pma_portcounters_ext *p =
1119 (struct ib_pma_portcounters_ext *)pmp->data;
1120 struct ipath_ibdev *dev = to_idev(ibdev);
1121 u64 swords, rwords, spkts, rpkts, xwait;
1122 u8 port_select = p->port_select;
1123
1124 ipath_snapshot_counters(dev->dd, &swords, &rwords, &spkts,
1125 &rpkts, &xwait);
1126
1127
1128 swords -= dev->z_port_xmit_data;
1129 rwords -= dev->z_port_rcv_data;
1130 spkts -= dev->z_port_xmit_packets;
1131 rpkts -= dev->z_port_rcv_packets;
1132
1133 memset(pmp->data, 0, sizeof(pmp->data));
1134
1135 p->port_select = port_select;
1136 if (pmp->mad_hdr.attr_mod != 0 ||
1137 (port_select != port && port_select != 0xFF))
1138 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
1139
1140 p->port_xmit_data = cpu_to_be64(swords);
1141 p->port_rcv_data = cpu_to_be64(rwords);
1142 p->port_xmit_packets = cpu_to_be64(spkts);
1143 p->port_rcv_packets = cpu_to_be64(rpkts);
1144 p->port_unicast_xmit_packets = cpu_to_be64(dev->n_unicast_xmit);
1145 p->port_unicast_rcv_packets = cpu_to_be64(dev->n_unicast_rcv);
1146 p->port_multicast_xmit_packets = cpu_to_be64(dev->n_multicast_xmit);
1147 p->port_multicast_rcv_packets = cpu_to_be64(dev->n_multicast_rcv);
1148
1149 return reply((struct ib_smp *) pmp);
1150}
1151
1152static int recv_pma_set_portcounters(struct ib_pma_mad *pmp,
1153 struct ib_device *ibdev, u8 port)
1154{
1155 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
1156 pmp->data;
1157 struct ipath_ibdev *dev = to_idev(ibdev);
1158 struct ipath_verbs_counters cntrs;
1159
1160
1161
1162
1163
1164 ipath_get_counters(dev->dd, &cntrs);
1165
1166 if (p->counter_select & IB_PMA_SEL_SYMBOL_ERROR)
1167 dev->z_symbol_error_counter = cntrs.symbol_error_counter;
1168
1169 if (p->counter_select & IB_PMA_SEL_LINK_ERROR_RECOVERY)
1170 dev->z_link_error_recovery_counter =
1171 cntrs.link_error_recovery_counter;
1172
1173 if (p->counter_select & IB_PMA_SEL_LINK_DOWNED)
1174 dev->z_link_downed_counter = cntrs.link_downed_counter;
1175
1176 if (p->counter_select & IB_PMA_SEL_PORT_RCV_ERRORS)
1177 dev->z_port_rcv_errors =
1178 cntrs.port_rcv_errors + dev->rcv_errors;
1179
1180 if (p->counter_select & IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS)
1181 dev->z_port_rcv_remphys_errors =
1182 cntrs.port_rcv_remphys_errors;
1183
1184 if (p->counter_select & IB_PMA_SEL_PORT_XMIT_DISCARDS)
1185 dev->z_port_xmit_discards = cntrs.port_xmit_discards;
1186
1187 if (p->counter_select & IB_PMA_SEL_LOCAL_LINK_INTEGRITY_ERRORS)
1188 dev->z_local_link_integrity_errors =
1189 cntrs.local_link_integrity_errors;
1190
1191 if (p->counter_select & IB_PMA_SEL_EXCESSIVE_BUFFER_OVERRUNS)
1192 dev->z_excessive_buffer_overrun_errors =
1193 cntrs.excessive_buffer_overrun_errors;
1194
1195 if (p->counter_select & IB_PMA_SEL_PORT_VL15_DROPPED) {
1196 dev->n_vl15_dropped = 0;
1197 dev->z_vl15_dropped = cntrs.vl15_dropped;
1198 }
1199
1200 if (p->counter_select & IB_PMA_SEL_PORT_XMIT_DATA)
1201 dev->z_port_xmit_data = cntrs.port_xmit_data;
1202
1203 if (p->counter_select & IB_PMA_SEL_PORT_RCV_DATA)
1204 dev->z_port_rcv_data = cntrs.port_rcv_data;
1205
1206 if (p->counter_select & IB_PMA_SEL_PORT_XMIT_PACKETS)
1207 dev->z_port_xmit_packets = cntrs.port_xmit_packets;
1208
1209 if (p->counter_select & IB_PMA_SEL_PORT_RCV_PACKETS)
1210 dev->z_port_rcv_packets = cntrs.port_rcv_packets;
1211
1212 return recv_pma_get_portcounters(pmp, ibdev, port);
1213}
1214
1215static int recv_pma_set_portcounters_ext(struct ib_pma_mad *pmp,
1216 struct ib_device *ibdev, u8 port)
1217{
1218 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
1219 pmp->data;
1220 struct ipath_ibdev *dev = to_idev(ibdev);
1221 u64 swords, rwords, spkts, rpkts, xwait;
1222
1223 ipath_snapshot_counters(dev->dd, &swords, &rwords, &spkts,
1224 &rpkts, &xwait);
1225
1226 if (p->counter_select & IB_PMA_SELX_PORT_XMIT_DATA)
1227 dev->z_port_xmit_data = swords;
1228
1229 if (p->counter_select & IB_PMA_SELX_PORT_RCV_DATA)
1230 dev->z_port_rcv_data = rwords;
1231
1232 if (p->counter_select & IB_PMA_SELX_PORT_XMIT_PACKETS)
1233 dev->z_port_xmit_packets = spkts;
1234
1235 if (p->counter_select & IB_PMA_SELX_PORT_RCV_PACKETS)
1236 dev->z_port_rcv_packets = rpkts;
1237
1238 if (p->counter_select & IB_PMA_SELX_PORT_UNI_XMIT_PACKETS)
1239 dev->n_unicast_xmit = 0;
1240
1241 if (p->counter_select & IB_PMA_SELX_PORT_UNI_RCV_PACKETS)
1242 dev->n_unicast_rcv = 0;
1243
1244 if (p->counter_select & IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS)
1245 dev->n_multicast_xmit = 0;
1246
1247 if (p->counter_select & IB_PMA_SELX_PORT_MULTI_RCV_PACKETS)
1248 dev->n_multicast_rcv = 0;
1249
1250 return recv_pma_get_portcounters_ext(pmp, ibdev, port);
1251}
1252
1253static int process_subn(struct ib_device *ibdev, int mad_flags,
1254 u8 port_num, struct ib_mad *in_mad,
1255 struct ib_mad *out_mad)
1256{
1257 struct ib_smp *smp = (struct ib_smp *)out_mad;
1258 struct ipath_ibdev *dev = to_idev(ibdev);
1259 int ret;
1260
1261 *out_mad = *in_mad;
1262 if (smp->class_version != 1) {
1263 smp->status |= IB_SMP_UNSUP_VERSION;
1264 ret = reply(smp);
1265 goto bail;
1266 }
1267
1268
1269 if (dev->mkey_lease_timeout &&
1270 time_after_eq(jiffies, dev->mkey_lease_timeout)) {
1271
1272 dev->mkey_lease_timeout = 0;
1273 dev->mkeyprot = 0;
1274 }
1275
1276
1277
1278
1279
1280 if ((mad_flags & IB_MAD_IGNORE_MKEY) == 0 && dev->mkey != 0 &&
1281 dev->mkey != smp->mkey &&
1282 (smp->method == IB_MGMT_METHOD_SET ||
1283 (smp->method == IB_MGMT_METHOD_GET &&
1284 dev->mkeyprot >= 2))) {
1285 if (dev->mkey_violations != 0xFFFF)
1286 ++dev->mkey_violations;
1287 if (dev->mkey_lease_timeout ||
1288 dev->mkey_lease_period == 0) {
1289 ret = IB_MAD_RESULT_SUCCESS |
1290 IB_MAD_RESULT_CONSUMED;
1291 goto bail;
1292 }
1293 dev->mkey_lease_timeout = jiffies +
1294 dev->mkey_lease_period * HZ;
1295
1296 ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
1297 goto bail;
1298 } else if (dev->mkey_lease_timeout)
1299 dev->mkey_lease_timeout = 0;
1300
1301 switch (smp->method) {
1302 case IB_MGMT_METHOD_GET:
1303 switch (smp->attr_id) {
1304 case IB_SMP_ATTR_NODE_DESC:
1305 ret = recv_subn_get_nodedescription(smp, ibdev);
1306 goto bail;
1307 case IB_SMP_ATTR_NODE_INFO:
1308 ret = recv_subn_get_nodeinfo(smp, ibdev, port_num);
1309 goto bail;
1310 case IB_SMP_ATTR_GUID_INFO:
1311 ret = recv_subn_get_guidinfo(smp, ibdev);
1312 goto bail;
1313 case IB_SMP_ATTR_PORT_INFO:
1314 ret = recv_subn_get_portinfo(smp, ibdev, port_num);
1315 goto bail;
1316 case IB_SMP_ATTR_PKEY_TABLE:
1317 ret = recv_subn_get_pkeytable(smp, ibdev);
1318 goto bail;
1319 case IB_SMP_ATTR_SM_INFO:
1320 if (dev->port_cap_flags & IB_PORT_SM_DISABLED) {
1321 ret = IB_MAD_RESULT_SUCCESS |
1322 IB_MAD_RESULT_CONSUMED;
1323 goto bail;
1324 }
1325 if (dev->port_cap_flags & IB_PORT_SM) {
1326 ret = IB_MAD_RESULT_SUCCESS;
1327 goto bail;
1328 }
1329
1330 default:
1331 smp->status |= IB_SMP_UNSUP_METH_ATTR;
1332 ret = reply(smp);
1333 goto bail;
1334 }
1335
1336 case IB_MGMT_METHOD_SET:
1337 switch (smp->attr_id) {
1338 case IB_SMP_ATTR_GUID_INFO:
1339 ret = recv_subn_set_guidinfo(smp, ibdev);
1340 goto bail;
1341 case IB_SMP_ATTR_PORT_INFO:
1342 ret = recv_subn_set_portinfo(smp, ibdev, port_num);
1343 goto bail;
1344 case IB_SMP_ATTR_PKEY_TABLE:
1345 ret = recv_subn_set_pkeytable(smp, ibdev);
1346 goto bail;
1347 case IB_SMP_ATTR_SM_INFO:
1348 if (dev->port_cap_flags & IB_PORT_SM_DISABLED) {
1349 ret = IB_MAD_RESULT_SUCCESS |
1350 IB_MAD_RESULT_CONSUMED;
1351 goto bail;
1352 }
1353 if (dev->port_cap_flags & IB_PORT_SM) {
1354 ret = IB_MAD_RESULT_SUCCESS;
1355 goto bail;
1356 }
1357
1358 default:
1359 smp->status |= IB_SMP_UNSUP_METH_ATTR;
1360 ret = reply(smp);
1361 goto bail;
1362 }
1363
1364 case IB_MGMT_METHOD_TRAP:
1365 case IB_MGMT_METHOD_REPORT:
1366 case IB_MGMT_METHOD_REPORT_RESP:
1367 case IB_MGMT_METHOD_TRAP_REPRESS:
1368 case IB_MGMT_METHOD_GET_RESP:
1369
1370
1371
1372
1373
1374 ret = IB_MAD_RESULT_SUCCESS;
1375 goto bail;
1376 default:
1377 smp->status |= IB_SMP_UNSUP_METHOD;
1378 ret = reply(smp);
1379 }
1380
1381bail:
1382 return ret;
1383}
1384
1385static int process_perf(struct ib_device *ibdev, u8 port_num,
1386 struct ib_mad *in_mad,
1387 struct ib_mad *out_mad)
1388{
1389 struct ib_pma_mad *pmp = (struct ib_pma_mad *)out_mad;
1390 int ret;
1391
1392 *out_mad = *in_mad;
1393 if (pmp->mad_hdr.class_version != 1) {
1394 pmp->mad_hdr.status |= IB_SMP_UNSUP_VERSION;
1395 ret = reply((struct ib_smp *) pmp);
1396 goto bail;
1397 }
1398
1399 switch (pmp->mad_hdr.method) {
1400 case IB_MGMT_METHOD_GET:
1401 switch (pmp->mad_hdr.attr_id) {
1402 case IB_PMA_CLASS_PORT_INFO:
1403 ret = recv_pma_get_classportinfo(pmp);
1404 goto bail;
1405 case IB_PMA_PORT_SAMPLES_CONTROL:
1406 ret = recv_pma_get_portsamplescontrol(pmp, ibdev,
1407 port_num);
1408 goto bail;
1409 case IB_PMA_PORT_SAMPLES_RESULT:
1410 ret = recv_pma_get_portsamplesresult(pmp, ibdev);
1411 goto bail;
1412 case IB_PMA_PORT_SAMPLES_RESULT_EXT:
1413 ret = recv_pma_get_portsamplesresult_ext(pmp,
1414 ibdev);
1415 goto bail;
1416 case IB_PMA_PORT_COUNTERS:
1417 ret = recv_pma_get_portcounters(pmp, ibdev,
1418 port_num);
1419 goto bail;
1420 case IB_PMA_PORT_COUNTERS_EXT:
1421 ret = recv_pma_get_portcounters_ext(pmp, ibdev,
1422 port_num);
1423 goto bail;
1424 default:
1425 pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
1426 ret = reply((struct ib_smp *) pmp);
1427 goto bail;
1428 }
1429
1430 case IB_MGMT_METHOD_SET:
1431 switch (pmp->mad_hdr.attr_id) {
1432 case IB_PMA_PORT_SAMPLES_CONTROL:
1433 ret = recv_pma_set_portsamplescontrol(pmp, ibdev,
1434 port_num);
1435 goto bail;
1436 case IB_PMA_PORT_COUNTERS:
1437 ret = recv_pma_set_portcounters(pmp, ibdev,
1438 port_num);
1439 goto bail;
1440 case IB_PMA_PORT_COUNTERS_EXT:
1441 ret = recv_pma_set_portcounters_ext(pmp, ibdev,
1442 port_num);
1443 goto bail;
1444 default:
1445 pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
1446 ret = reply((struct ib_smp *) pmp);
1447 goto bail;
1448 }
1449
1450 case IB_MGMT_METHOD_GET_RESP:
1451
1452
1453
1454
1455
1456 ret = IB_MAD_RESULT_SUCCESS;
1457 goto bail;
1458 default:
1459 pmp->mad_hdr.status |= IB_SMP_UNSUP_METHOD;
1460 ret = reply((struct ib_smp *) pmp);
1461 }
1462
1463bail:
1464 return ret;
1465}
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486int ipath_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
1487 struct ib_wc *in_wc, struct ib_grh *in_grh,
1488 struct ib_mad *in_mad, struct ib_mad *out_mad)
1489{
1490 int ret;
1491
1492 switch (in_mad->mad_hdr.mgmt_class) {
1493 case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
1494 case IB_MGMT_CLASS_SUBN_LID_ROUTED:
1495 ret = process_subn(ibdev, mad_flags, port_num,
1496 in_mad, out_mad);
1497 goto bail;
1498 case IB_MGMT_CLASS_PERF_MGMT:
1499 ret = process_perf(ibdev, port_num, in_mad, out_mad);
1500 goto bail;
1501 default:
1502 ret = IB_MAD_RESULT_SUCCESS;
1503 }
1504
1505bail:
1506 return ret;
1507}
1508