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
46
47
48#include <linux/net.h>
49#include <rdma/opa_addr.h>
50#define OPA_NUM_PKEY_BLOCKS_PER_SMP (OPA_SMP_DR_DATA_SIZE \
51 / (OPA_PARTITION_TABLE_BLK_SIZE * sizeof(u16)))
52
53#include "hfi.h"
54#include "mad.h"
55#include "trace.h"
56#include "qp.h"
57#include "vnic.h"
58
59
60#define OPA_LINK_WIDTH_RESET_OLD 0x0fff
61#define OPA_LINK_WIDTH_RESET 0xffff
62
63struct trap_node {
64 struct list_head list;
65 struct opa_mad_notice_attr data;
66 __be64 tid;
67 int len;
68 u32 retry;
69 u8 in_use;
70 u8 repress;
71};
72
73static int smp_length_check(u32 data_size, u32 request_len)
74{
75 if (unlikely(request_len < data_size))
76 return -EINVAL;
77
78 return 0;
79}
80
81static int reply(struct ib_mad_hdr *smp)
82{
83
84
85
86
87 smp->method = IB_MGMT_METHOD_GET_RESP;
88 if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
89 smp->status |= IB_SMP_DIRECTION;
90 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
91}
92
93static inline void clear_opa_smp_data(struct opa_smp *smp)
94{
95 void *data = opa_get_smp_data(smp);
96 size_t size = opa_get_smp_data_size(smp);
97
98 memset(data, 0, size);
99}
100
101static u16 hfi1_lookup_pkey_value(struct hfi1_ibport *ibp, int pkey_idx)
102{
103 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
104
105 if (pkey_idx < ARRAY_SIZE(ppd->pkeys))
106 return ppd->pkeys[pkey_idx];
107
108 return 0;
109}
110
111void hfi1_event_pkey_change(struct hfi1_devdata *dd, u32 port)
112{
113 struct ib_event event;
114
115 event.event = IB_EVENT_PKEY_CHANGE;
116 event.device = &dd->verbs_dev.rdi.ibdev;
117 event.element.port_num = port;
118 ib_dispatch_event(&event);
119}
120
121
122
123
124
125static void cleanup_traps(struct hfi1_ibport *ibp, struct trap_node *trap)
126{
127 struct trap_node *node, *q;
128 unsigned long flags;
129 struct list_head trap_list;
130 int i;
131
132 for (i = 0; i < RVT_MAX_TRAP_LISTS; i++) {
133 spin_lock_irqsave(&ibp->rvp.lock, flags);
134 list_replace_init(&ibp->rvp.trap_lists[i].list, &trap_list);
135 ibp->rvp.trap_lists[i].list_len = 0;
136 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
137
138
139
140
141
142 list_for_each_entry_safe(node, q, &trap_list, list) {
143 list_del(&node->list);
144 if (node != trap)
145 kfree(node);
146 }
147 }
148
149
150
151
152
153 kfree(trap);
154}
155
156static struct trap_node *check_and_add_trap(struct hfi1_ibport *ibp,
157 struct trap_node *trap)
158{
159 struct trap_node *node;
160 struct trap_list *trap_list;
161 unsigned long flags;
162 unsigned long timeout;
163 int found = 0;
164 unsigned int queue_id;
165 static int trap_count;
166
167 queue_id = trap->data.generic_type & 0x0F;
168 if (queue_id >= RVT_MAX_TRAP_LISTS) {
169 trap_count++;
170 pr_err_ratelimited("hfi1: Invalid trap 0x%0x dropped. Total dropped: %d\n",
171 trap->data.generic_type, trap_count);
172 kfree(trap);
173 return NULL;
174 }
175
176
177
178
179
180 spin_lock_irqsave(&ibp->rvp.lock, flags);
181 trap_list = &ibp->rvp.trap_lists[queue_id];
182
183 list_for_each_entry(node, &trap_list->list, list) {
184 if (node == trap) {
185 node->retry++;
186 found = 1;
187 break;
188 }
189 }
190
191
192 if (!found) {
193 if (trap_list->list_len < RVT_MAX_TRAP_LEN) {
194 trap_list->list_len++;
195 list_add_tail(&trap->list, &trap_list->list);
196 } else {
197 pr_warn_ratelimited("hfi1: Maximum trap limit reached for 0x%0x traps\n",
198 trap->data.generic_type);
199 kfree(trap);
200 }
201 }
202
203
204
205
206
207 node = NULL;
208 if (!timer_pending(&ibp->rvp.trap_timer)) {
209
210
211
212
213
214
215 timeout = (RVT_TRAP_TIMEOUT *
216 (1UL << ibp->rvp.subnet_timeout)) / 1000;
217 mod_timer(&ibp->rvp.trap_timer,
218 jiffies + usecs_to_jiffies(timeout));
219 node = list_first_entry(&trap_list->list, struct trap_node,
220 list);
221 node->in_use = 1;
222 }
223 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
224
225 return node;
226}
227
228static void subn_handle_opa_trap_repress(struct hfi1_ibport *ibp,
229 struct opa_smp *smp)
230{
231 struct trap_list *trap_list;
232 struct trap_node *trap;
233 unsigned long flags;
234 int i;
235
236 if (smp->attr_id != IB_SMP_ATTR_NOTICE)
237 return;
238
239 spin_lock_irqsave(&ibp->rvp.lock, flags);
240 for (i = 0; i < RVT_MAX_TRAP_LISTS; i++) {
241 trap_list = &ibp->rvp.trap_lists[i];
242 trap = list_first_entry_or_null(&trap_list->list,
243 struct trap_node, list);
244 if (trap && trap->tid == smp->tid) {
245 if (trap->in_use) {
246 trap->repress = 1;
247 } else {
248 trap_list->list_len--;
249 list_del(&trap->list);
250 kfree(trap);
251 }
252 break;
253 }
254 }
255 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
256}
257
258static void hfi1_update_sm_ah_attr(struct hfi1_ibport *ibp,
259 struct rdma_ah_attr *attr, u32 dlid)
260{
261 rdma_ah_set_dlid(attr, dlid);
262 rdma_ah_set_port_num(attr, ppd_from_ibp(ibp)->port);
263 if (dlid >= be16_to_cpu(IB_MULTICAST_LID_BASE)) {
264 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
265
266 rdma_ah_set_ah_flags(attr, IB_AH_GRH);
267 grh->sgid_index = 0;
268 grh->hop_limit = 1;
269 grh->dgid.global.subnet_prefix =
270 ibp->rvp.gid_prefix;
271 grh->dgid.global.interface_id = OPA_MAKE_ID(dlid);
272 }
273}
274
275static int hfi1_modify_qp0_ah(struct hfi1_ibport *ibp,
276 struct rvt_ah *ah, u32 dlid)
277{
278 struct rdma_ah_attr attr;
279 struct rvt_qp *qp0;
280 int ret = -EINVAL;
281
282 memset(&attr, 0, sizeof(attr));
283 attr.type = ah->ibah.type;
284 hfi1_update_sm_ah_attr(ibp, &attr, dlid);
285 rcu_read_lock();
286 qp0 = rcu_dereference(ibp->rvp.qp[0]);
287 if (qp0)
288 ret = rdma_modify_ah(&ah->ibah, &attr);
289 rcu_read_unlock();
290 return ret;
291}
292
293static struct ib_ah *hfi1_create_qp0_ah(struct hfi1_ibport *ibp, u32 dlid)
294{
295 struct rdma_ah_attr attr;
296 struct ib_ah *ah = ERR_PTR(-EINVAL);
297 struct rvt_qp *qp0;
298 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
299 struct hfi1_devdata *dd = dd_from_ppd(ppd);
300 u32 port_num = ppd->port;
301
302 memset(&attr, 0, sizeof(attr));
303 attr.type = rdma_ah_find_type(&dd->verbs_dev.rdi.ibdev, port_num);
304 hfi1_update_sm_ah_attr(ibp, &attr, dlid);
305 rcu_read_lock();
306 qp0 = rcu_dereference(ibp->rvp.qp[0]);
307 if (qp0)
308 ah = rdma_create_ah(qp0->ibqp.pd, &attr, 0);
309 rcu_read_unlock();
310 return ah;
311}
312
313static void send_trap(struct hfi1_ibport *ibp, struct trap_node *trap)
314{
315 struct ib_mad_send_buf *send_buf;
316 struct ib_mad_agent *agent;
317 struct opa_smp *smp;
318 unsigned long flags;
319 int pkey_idx;
320 u32 qpn = ppd_from_ibp(ibp)->sm_trap_qp;
321
322 agent = ibp->rvp.send_agent;
323 if (!agent) {
324 cleanup_traps(ibp, trap);
325 return;
326 }
327
328
329 if (driver_lstate(ppd_from_ibp(ibp)) != IB_PORT_ACTIVE) {
330 cleanup_traps(ibp, trap);
331 return;
332 }
333
334
335 trap = check_and_add_trap(ibp, trap);
336 if (!trap)
337 return;
338
339 pkey_idx = hfi1_lookup_pkey_idx(ibp, LIM_MGMT_P_KEY);
340 if (pkey_idx < 0) {
341 pr_warn("%s: failed to find limited mgmt pkey, defaulting 0x%x\n",
342 __func__, hfi1_get_pkey(ibp, 1));
343 pkey_idx = 1;
344 }
345
346 send_buf = ib_create_send_mad(agent, qpn, pkey_idx, 0,
347 IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
348 GFP_ATOMIC, IB_MGMT_BASE_VERSION);
349 if (IS_ERR(send_buf))
350 return;
351
352 smp = send_buf->mad;
353 smp->base_version = OPA_MGMT_BASE_VERSION;
354 smp->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
355 smp->class_version = OPA_SM_CLASS_VERSION;
356 smp->method = IB_MGMT_METHOD_TRAP;
357
358
359 if (trap->tid == 0) {
360 ibp->rvp.tid++;
361
362 if (ibp->rvp.tid == 0)
363 ibp->rvp.tid++;
364 trap->tid = cpu_to_be64(ibp->rvp.tid);
365 }
366 smp->tid = trap->tid;
367
368 smp->attr_id = IB_SMP_ATTR_NOTICE;
369
370
371 memcpy(smp->route.lid.data, &trap->data, trap->len);
372
373 spin_lock_irqsave(&ibp->rvp.lock, flags);
374 if (!ibp->rvp.sm_ah) {
375 if (ibp->rvp.sm_lid != be16_to_cpu(IB_LID_PERMISSIVE)) {
376 struct ib_ah *ah;
377
378 ah = hfi1_create_qp0_ah(ibp, ibp->rvp.sm_lid);
379 if (IS_ERR(ah)) {
380 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
381 return;
382 }
383 send_buf->ah = ah;
384 ibp->rvp.sm_ah = ibah_to_rvtah(ah);
385 } else {
386 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
387 return;
388 }
389 } else {
390 send_buf->ah = &ibp->rvp.sm_ah->ibah;
391 }
392
393
394
395
396
397 if (trap->repress) {
398 list_del(&trap->list);
399 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
400 kfree(trap);
401 ib_free_send_mad(send_buf);
402 return;
403 }
404
405 trap->in_use = 0;
406 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
407
408 if (ib_post_send_mad(send_buf, NULL))
409 ib_free_send_mad(send_buf);
410}
411
412void hfi1_handle_trap_timer(struct timer_list *t)
413{
414 struct hfi1_ibport *ibp = from_timer(ibp, t, rvp.trap_timer);
415 struct trap_node *trap = NULL;
416 unsigned long flags;
417 int i;
418
419
420 spin_lock_irqsave(&ibp->rvp.lock, flags);
421 for (i = 0; !trap && i < RVT_MAX_TRAP_LISTS; i++) {
422 trap = list_first_entry_or_null(&ibp->rvp.trap_lists[i].list,
423 struct trap_node, list);
424 }
425 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
426
427 if (trap)
428 send_trap(ibp, trap);
429}
430
431static struct trap_node *create_trap_node(u8 type, __be16 trap_num, u32 lid)
432{
433 struct trap_node *trap;
434
435 trap = kzalloc(sizeof(*trap), GFP_ATOMIC);
436 if (!trap)
437 return NULL;
438
439 INIT_LIST_HEAD(&trap->list);
440 trap->data.generic_type = type;
441 trap->data.prod_type_lsb = IB_NOTICE_PROD_CA;
442 trap->data.trap_num = trap_num;
443 trap->data.issuer_lid = cpu_to_be32(lid);
444
445 return trap;
446}
447
448
449
450
451void hfi1_bad_pkey(struct hfi1_ibport *ibp, u32 key, u32 sl,
452 u32 qp1, u32 qp2, u32 lid1, u32 lid2)
453{
454 struct trap_node *trap;
455 u32 lid = ppd_from_ibp(ibp)->lid;
456
457 ibp->rvp.n_pkt_drops++;
458 ibp->rvp.pkey_violations++;
459
460 trap = create_trap_node(IB_NOTICE_TYPE_SECURITY, OPA_TRAP_BAD_P_KEY,
461 lid);
462 if (!trap)
463 return;
464
465
466 trap->data.ntc_257_258.lid1 = cpu_to_be32(lid1);
467 trap->data.ntc_257_258.lid2 = cpu_to_be32(lid2);
468 trap->data.ntc_257_258.key = cpu_to_be32(key);
469 trap->data.ntc_257_258.sl = sl << 3;
470 trap->data.ntc_257_258.qp1 = cpu_to_be32(qp1);
471 trap->data.ntc_257_258.qp2 = cpu_to_be32(qp2);
472
473 trap->len = sizeof(trap->data);
474 send_trap(ibp, trap);
475}
476
477
478
479
480static void bad_mkey(struct hfi1_ibport *ibp, struct ib_mad_hdr *mad,
481 __be64 mkey, __be32 dr_slid, u8 return_path[], u8 hop_cnt)
482{
483 struct trap_node *trap;
484 u32 lid = ppd_from_ibp(ibp)->lid;
485
486 trap = create_trap_node(IB_NOTICE_TYPE_SECURITY, OPA_TRAP_BAD_M_KEY,
487 lid);
488 if (!trap)
489 return;
490
491
492 trap->data.ntc_256.lid = trap->data.issuer_lid;
493 trap->data.ntc_256.method = mad->method;
494 trap->data.ntc_256.attr_id = mad->attr_id;
495 trap->data.ntc_256.attr_mod = mad->attr_mod;
496 trap->data.ntc_256.mkey = mkey;
497 if (mad->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) {
498 trap->data.ntc_256.dr_slid = dr_slid;
499 trap->data.ntc_256.dr_trunc_hop = IB_NOTICE_TRAP_DR_NOTICE;
500 if (hop_cnt > ARRAY_SIZE(trap->data.ntc_256.dr_rtn_path)) {
501 trap->data.ntc_256.dr_trunc_hop |=
502 IB_NOTICE_TRAP_DR_TRUNC;
503 hop_cnt = ARRAY_SIZE(trap->data.ntc_256.dr_rtn_path);
504 }
505 trap->data.ntc_256.dr_trunc_hop |= hop_cnt;
506 memcpy(trap->data.ntc_256.dr_rtn_path, return_path,
507 hop_cnt);
508 }
509
510 trap->len = sizeof(trap->data);
511
512 send_trap(ibp, trap);
513}
514
515
516
517
518void hfi1_cap_mask_chg(struct rvt_dev_info *rdi, u32 port_num)
519{
520 struct trap_node *trap;
521 struct hfi1_ibdev *verbs_dev = dev_from_rdi(rdi);
522 struct hfi1_devdata *dd = dd_from_dev(verbs_dev);
523 struct hfi1_ibport *ibp = &dd->pport[port_num - 1].ibport_data;
524 u32 lid = ppd_from_ibp(ibp)->lid;
525
526 trap = create_trap_node(IB_NOTICE_TYPE_INFO,
527 OPA_TRAP_CHANGE_CAPABILITY,
528 lid);
529 if (!trap)
530 return;
531
532 trap->data.ntc_144.lid = trap->data.issuer_lid;
533 trap->data.ntc_144.new_cap_mask = cpu_to_be32(ibp->rvp.port_cap_flags);
534 trap->data.ntc_144.cap_mask3 = cpu_to_be16(ibp->rvp.port_cap3_flags);
535
536 trap->len = sizeof(trap->data);
537 send_trap(ibp, trap);
538}
539
540
541
542
543void hfi1_sys_guid_chg(struct hfi1_ibport *ibp)
544{
545 struct trap_node *trap;
546 u32 lid = ppd_from_ibp(ibp)->lid;
547
548 trap = create_trap_node(IB_NOTICE_TYPE_INFO, OPA_TRAP_CHANGE_SYSGUID,
549 lid);
550 if (!trap)
551 return;
552
553 trap->data.ntc_145.new_sys_guid = ib_hfi1_sys_image_guid;
554 trap->data.ntc_145.lid = trap->data.issuer_lid;
555
556 trap->len = sizeof(trap->data);
557 send_trap(ibp, trap);
558}
559
560
561
562
563void hfi1_node_desc_chg(struct hfi1_ibport *ibp)
564{
565 struct trap_node *trap;
566 u32 lid = ppd_from_ibp(ibp)->lid;
567
568 trap = create_trap_node(IB_NOTICE_TYPE_INFO,
569 OPA_TRAP_CHANGE_CAPABILITY,
570 lid);
571 if (!trap)
572 return;
573
574 trap->data.ntc_144.lid = trap->data.issuer_lid;
575 trap->data.ntc_144.change_flags =
576 cpu_to_be16(OPA_NOTICE_TRAP_NODE_DESC_CHG);
577
578 trap->len = sizeof(trap->data);
579 send_trap(ibp, trap);
580}
581
582static int __subn_get_opa_nodedesc(struct opa_smp *smp, u32 am,
583 u8 *data, struct ib_device *ibdev,
584 u32 port, u32 *resp_len, u32 max_len)
585{
586 struct opa_node_description *nd;
587
588 if (am || smp_length_check(sizeof(*nd), max_len)) {
589 smp->status |= IB_SMP_INVALID_FIELD;
590 return reply((struct ib_mad_hdr *)smp);
591 }
592
593 nd = (struct opa_node_description *)data;
594
595 memcpy(nd->data, ibdev->node_desc, sizeof(nd->data));
596
597 if (resp_len)
598 *resp_len += sizeof(*nd);
599
600 return reply((struct ib_mad_hdr *)smp);
601}
602
603static int __subn_get_opa_nodeinfo(struct opa_smp *smp, u32 am, u8 *data,
604 struct ib_device *ibdev, u32 port,
605 u32 *resp_len, u32 max_len)
606{
607 struct opa_node_info *ni;
608 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
609 u32 pidx = port - 1;
610
611 ni = (struct opa_node_info *)data;
612
613
614 if (am || pidx >= dd->num_pports || ibdev->node_guid == 0 ||
615 smp_length_check(sizeof(*ni), max_len) ||
616 get_sguid(to_iport(ibdev, port), HFI1_PORT_GUID_INDEX) == 0) {
617 smp->status |= IB_SMP_INVALID_FIELD;
618 return reply((struct ib_mad_hdr *)smp);
619 }
620
621 ni->port_guid = get_sguid(to_iport(ibdev, port), HFI1_PORT_GUID_INDEX);
622 ni->base_version = OPA_MGMT_BASE_VERSION;
623 ni->class_version = OPA_SM_CLASS_VERSION;
624 ni->node_type = 1;
625 ni->num_ports = ibdev->phys_port_cnt;
626
627 ni->system_image_guid = ib_hfi1_sys_image_guid;
628 ni->node_guid = ibdev->node_guid;
629 ni->partition_cap = cpu_to_be16(hfi1_get_npkeys(dd));
630 ni->device_id = cpu_to_be16(dd->pcidev->device);
631 ni->revision = cpu_to_be32(dd->minrev);
632 ni->local_port_num = port;
633 ni->vendor_id[0] = dd->oui1;
634 ni->vendor_id[1] = dd->oui2;
635 ni->vendor_id[2] = dd->oui3;
636
637 if (resp_len)
638 *resp_len += sizeof(*ni);
639
640 return reply((struct ib_mad_hdr *)smp);
641}
642
643static int subn_get_nodeinfo(struct ib_smp *smp, struct ib_device *ibdev,
644 u32 port)
645{
646 struct ib_node_info *nip = (struct ib_node_info *)&smp->data;
647 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
648 u32 pidx = port - 1;
649
650
651 if (smp->attr_mod || pidx >= dd->num_pports ||
652 ibdev->node_guid == 0 ||
653 get_sguid(to_iport(ibdev, port), HFI1_PORT_GUID_INDEX) == 0) {
654 smp->status |= IB_SMP_INVALID_FIELD;
655 return reply((struct ib_mad_hdr *)smp);
656 }
657
658 nip->port_guid = get_sguid(to_iport(ibdev, port), HFI1_PORT_GUID_INDEX);
659 nip->base_version = OPA_MGMT_BASE_VERSION;
660 nip->class_version = OPA_SM_CLASS_VERSION;
661 nip->node_type = 1;
662 nip->num_ports = ibdev->phys_port_cnt;
663
664 nip->sys_guid = ib_hfi1_sys_image_guid;
665 nip->node_guid = ibdev->node_guid;
666 nip->partition_cap = cpu_to_be16(hfi1_get_npkeys(dd));
667 nip->device_id = cpu_to_be16(dd->pcidev->device);
668 nip->revision = cpu_to_be32(dd->minrev);
669 nip->local_port_num = port;
670 nip->vendor_id[0] = dd->oui1;
671 nip->vendor_id[1] = dd->oui2;
672 nip->vendor_id[2] = dd->oui3;
673
674 return reply((struct ib_mad_hdr *)smp);
675}
676
677static void set_link_width_enabled(struct hfi1_pportdata *ppd, u32 w)
678{
679 (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_LWID_ENB, w);
680}
681
682static void set_link_width_downgrade_enabled(struct hfi1_pportdata *ppd, u32 w)
683{
684 (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_LWID_DG_ENB, w);
685}
686
687static void set_link_speed_enabled(struct hfi1_pportdata *ppd, u32 s)
688{
689 (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_SPD_ENB, s);
690}
691
692static int check_mkey(struct hfi1_ibport *ibp, struct ib_mad_hdr *mad,
693 int mad_flags, __be64 mkey, __be32 dr_slid,
694 u8 return_path[], u8 hop_cnt)
695{
696 int valid_mkey = 0;
697 int ret = 0;
698
699
700 if (ibp->rvp.mkey_lease_timeout &&
701 time_after_eq(jiffies, ibp->rvp.mkey_lease_timeout)) {
702
703 ibp->rvp.mkey_lease_timeout = 0;
704 ibp->rvp.mkeyprot = 0;
705 }
706
707 if ((mad_flags & IB_MAD_IGNORE_MKEY) || ibp->rvp.mkey == 0 ||
708 ibp->rvp.mkey == mkey)
709 valid_mkey = 1;
710
711
712 if (valid_mkey && ibp->rvp.mkey_lease_timeout &&
713 (mad->method == IB_MGMT_METHOD_GET ||
714 mad->method == IB_MGMT_METHOD_SET ||
715 mad->method == IB_MGMT_METHOD_TRAP_REPRESS))
716 ibp->rvp.mkey_lease_timeout = 0;
717
718 if (!valid_mkey) {
719 switch (mad->method) {
720 case IB_MGMT_METHOD_GET:
721
722 if (ibp->rvp.mkeyprot < 2)
723 break;
724 fallthrough;
725 case IB_MGMT_METHOD_SET:
726 case IB_MGMT_METHOD_TRAP_REPRESS:
727 if (ibp->rvp.mkey_violations != 0xFFFF)
728 ++ibp->rvp.mkey_violations;
729 if (!ibp->rvp.mkey_lease_timeout &&
730 ibp->rvp.mkey_lease_period)
731 ibp->rvp.mkey_lease_timeout = jiffies +
732 ibp->rvp.mkey_lease_period * HZ;
733
734 bad_mkey(ibp, mad, mkey, dr_slid, return_path,
735 hop_cnt);
736 ret = 1;
737 }
738 }
739
740 return ret;
741}
742
743
744
745
746
747struct lcb_datum {
748 u32 off;
749 u64 val;
750};
751
752static struct lcb_datum lcb_cache[] = {
753 { DC_LCB_STS_ROUND_TRIP_LTP_CNT, 0 },
754};
755
756static int write_lcb_cache(u32 off, u64 val)
757{
758 int i;
759
760 for (i = 0; i < ARRAY_SIZE(lcb_cache); i++) {
761 if (lcb_cache[i].off == off) {
762 lcb_cache[i].val = val;
763 return 0;
764 }
765 }
766
767 pr_warn("%s bad offset 0x%x\n", __func__, off);
768 return -1;
769}
770
771static int read_lcb_cache(u32 off, u64 *val)
772{
773 int i;
774
775 for (i = 0; i < ARRAY_SIZE(lcb_cache); i++) {
776 if (lcb_cache[i].off == off) {
777 *val = lcb_cache[i].val;
778 return 0;
779 }
780 }
781
782 pr_warn("%s bad offset 0x%x\n", __func__, off);
783 return -1;
784}
785
786void read_ltp_rtt(struct hfi1_devdata *dd)
787{
788 u64 reg;
789
790 if (read_lcb_csr(dd, DC_LCB_STS_ROUND_TRIP_LTP_CNT, ®))
791 dd_dev_err(dd, "%s: unable to read LTP RTT\n", __func__);
792 else
793 write_lcb_cache(DC_LCB_STS_ROUND_TRIP_LTP_CNT, reg);
794}
795
796static int __subn_get_opa_portinfo(struct opa_smp *smp, u32 am, u8 *data,
797 struct ib_device *ibdev, u32 port,
798 u32 *resp_len, u32 max_len)
799{
800 int i;
801 struct hfi1_devdata *dd;
802 struct hfi1_pportdata *ppd;
803 struct hfi1_ibport *ibp;
804 struct opa_port_info *pi = (struct opa_port_info *)data;
805 u8 mtu;
806 u8 credit_rate;
807 u8 is_beaconing_active;
808 u32 state;
809 u32 num_ports = OPA_AM_NPORT(am);
810 u32 start_of_sm_config = OPA_AM_START_SM_CFG(am);
811 u32 buffer_units;
812 u64 tmp = 0;
813
814 if (num_ports != 1 || smp_length_check(sizeof(*pi), max_len)) {
815 smp->status |= IB_SMP_INVALID_FIELD;
816 return reply((struct ib_mad_hdr *)smp);
817 }
818
819 dd = dd_from_ibdev(ibdev);
820
821 ppd = dd->pport + (port - 1);
822 ibp = &ppd->ibport_data;
823
824 if (ppd->vls_supported / 2 > ARRAY_SIZE(pi->neigh_mtu.pvlx_to_mtu) ||
825 ppd->vls_supported > ARRAY_SIZE(dd->vld)) {
826 smp->status |= IB_SMP_INVALID_FIELD;
827 return reply((struct ib_mad_hdr *)smp);
828 }
829
830 pi->lid = cpu_to_be32(ppd->lid);
831
832
833 if (!(smp->method == IB_MGMT_METHOD_GET &&
834 ibp->rvp.mkey != smp->mkey &&
835 ibp->rvp.mkeyprot == 1))
836 pi->mkey = ibp->rvp.mkey;
837
838 pi->subnet_prefix = ibp->rvp.gid_prefix;
839 pi->sm_lid = cpu_to_be32(ibp->rvp.sm_lid);
840 pi->ib_cap_mask = cpu_to_be32(ibp->rvp.port_cap_flags);
841 pi->mkey_lease_period = cpu_to_be16(ibp->rvp.mkey_lease_period);
842 pi->sm_trap_qp = cpu_to_be32(ppd->sm_trap_qp);
843 pi->sa_qp = cpu_to_be32(ppd->sa_qp);
844
845 pi->link_width.enabled = cpu_to_be16(ppd->link_width_enabled);
846 pi->link_width.supported = cpu_to_be16(ppd->link_width_supported);
847 pi->link_width.active = cpu_to_be16(ppd->link_width_active);
848
849 pi->link_width_downgrade.supported =
850 cpu_to_be16(ppd->link_width_downgrade_supported);
851 pi->link_width_downgrade.enabled =
852 cpu_to_be16(ppd->link_width_downgrade_enabled);
853 pi->link_width_downgrade.tx_active =
854 cpu_to_be16(ppd->link_width_downgrade_tx_active);
855 pi->link_width_downgrade.rx_active =
856 cpu_to_be16(ppd->link_width_downgrade_rx_active);
857
858 pi->link_speed.supported = cpu_to_be16(ppd->link_speed_supported);
859 pi->link_speed.active = cpu_to_be16(ppd->link_speed_active);
860 pi->link_speed.enabled = cpu_to_be16(ppd->link_speed_enabled);
861
862 state = driver_lstate(ppd);
863
864 if (start_of_sm_config && (state == IB_PORT_INIT))
865 ppd->is_sm_config_started = 1;
866
867 pi->port_phys_conf = (ppd->port_type & 0xf);
868
869 pi->port_states.ledenable_offlinereason = ppd->neighbor_normal << 4;
870 pi->port_states.ledenable_offlinereason |=
871 ppd->is_sm_config_started << 5;
872
873
874
875
876
877 smp_rmb();
878 is_beaconing_active = !!atomic_read(&ppd->led_override_timer_active);
879 pi->port_states.ledenable_offlinereason |= is_beaconing_active << 6;
880 pi->port_states.ledenable_offlinereason |=
881 ppd->offline_disabled_reason;
882
883 pi->port_states.portphysstate_portstate =
884 (driver_pstate(ppd) << 4) | state;
885
886 pi->mkeyprotect_lmc = (ibp->rvp.mkeyprot << 6) | ppd->lmc;
887
888 memset(pi->neigh_mtu.pvlx_to_mtu, 0, sizeof(pi->neigh_mtu.pvlx_to_mtu));
889 for (i = 0; i < ppd->vls_supported; i++) {
890 mtu = mtu_to_enum(dd->vld[i].mtu, HFI1_DEFAULT_ACTIVE_MTU);
891 if ((i % 2) == 0)
892 pi->neigh_mtu.pvlx_to_mtu[i / 2] |= (mtu << 4);
893 else
894 pi->neigh_mtu.pvlx_to_mtu[i / 2] |= mtu;
895 }
896
897 mtu = mtu_to_enum(dd->vld[15].mtu, 2048);
898 pi->neigh_mtu.pvlx_to_mtu[15 / 2] |= mtu;
899 pi->smsl = ibp->rvp.sm_sl & OPA_PI_MASK_SMSL;
900 pi->operational_vls = hfi1_get_ib_cfg(ppd, HFI1_IB_CFG_OP_VLS);
901 pi->partenforce_filterraw |=
902 (ppd->linkinit_reason & OPA_PI_MASK_LINKINIT_REASON);
903 if (ppd->part_enforce & HFI1_PART_ENFORCE_IN)
904 pi->partenforce_filterraw |= OPA_PI_MASK_PARTITION_ENFORCE_IN;
905 if (ppd->part_enforce & HFI1_PART_ENFORCE_OUT)
906 pi->partenforce_filterraw |= OPA_PI_MASK_PARTITION_ENFORCE_OUT;
907 pi->mkey_violations = cpu_to_be16(ibp->rvp.mkey_violations);
908
909 pi->pkey_violations = cpu_to_be16(ibp->rvp.pkey_violations);
910 pi->qkey_violations = cpu_to_be16(ibp->rvp.qkey_violations);
911
912 pi->vl.cap = ppd->vls_supported;
913 pi->vl.high_limit = cpu_to_be16(ibp->rvp.vl_high_limit);
914 pi->vl.arb_high_cap = (u8)hfi1_get_ib_cfg(ppd, HFI1_IB_CFG_VL_HIGH_CAP);
915 pi->vl.arb_low_cap = (u8)hfi1_get_ib_cfg(ppd, HFI1_IB_CFG_VL_LOW_CAP);
916
917 pi->clientrereg_subnettimeout = ibp->rvp.subnet_timeout;
918
919 pi->port_link_mode = cpu_to_be16(OPA_PORT_LINK_MODE_OPA << 10 |
920 OPA_PORT_LINK_MODE_OPA << 5 |
921 OPA_PORT_LINK_MODE_OPA);
922
923 pi->port_ltp_crc_mode = cpu_to_be16(ppd->port_ltp_crc_mode);
924
925 pi->port_mode = cpu_to_be16(
926 ppd->is_active_optimize_enabled ?
927 OPA_PI_MASK_PORT_ACTIVE_OPTOMIZE : 0);
928
929 pi->port_packet_format.supported =
930 cpu_to_be16(OPA_PORT_PACKET_FORMAT_9B |
931 OPA_PORT_PACKET_FORMAT_16B);
932 pi->port_packet_format.enabled =
933 cpu_to_be16(OPA_PORT_PACKET_FORMAT_9B |
934 OPA_PORT_PACKET_FORMAT_16B);
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949 pi->flit_control.interleave = cpu_to_be16(0x1400);
950
951 pi->link_down_reason = ppd->local_link_down_reason.sma;
952 pi->neigh_link_down_reason = ppd->neigh_link_down_reason.sma;
953 pi->port_error_action = cpu_to_be32(ppd->port_error_action);
954 pi->mtucap = mtu_to_enum(hfi1_max_mtu, IB_MTU_4096);
955
956
957 pi->resptimevalue = 3;
958
959 pi->local_port_num = port;
960
961
962 pi->overall_buffer_space = cpu_to_be16(dd->link_credits);
963
964 pi->neigh_node_guid = cpu_to_be64(ppd->neighbor_guid);
965 pi->neigh_port_num = ppd->neighbor_port_number;
966 pi->port_neigh_mode =
967 (ppd->neighbor_type & OPA_PI_MASK_NEIGH_NODE_TYPE) |
968 (ppd->mgmt_allowed ? OPA_PI_MASK_NEIGH_MGMT_ALLOWED : 0) |
969 (ppd->neighbor_fm_security ?
970 OPA_PI_MASK_NEIGH_FW_AUTH_BYPASS : 0);
971
972
973
974
975 credit_rate = 0;
976 buffer_units = (dd->vau) & OPA_PI_MASK_BUF_UNIT_BUF_ALLOC;
977 buffer_units |= (dd->vcu << 3) & OPA_PI_MASK_BUF_UNIT_CREDIT_ACK;
978 buffer_units |= (credit_rate << 6) &
979 OPA_PI_MASK_BUF_UNIT_VL15_CREDIT_RATE;
980 buffer_units |= (dd->vl15_init << 11) & OPA_PI_MASK_BUF_UNIT_VL15_INIT;
981 pi->buffer_units = cpu_to_be32(buffer_units);
982
983 pi->opa_cap_mask = cpu_to_be16(ibp->rvp.port_cap3_flags);
984 pi->collectivemask_multicastmask = ((OPA_COLLECTIVE_NR & 0x7)
985 << 3 | (OPA_MCAST_NR & 0x7));
986
987
988 pi->replay_depth.buffer = 0x80;
989
990 read_lcb_cache(DC_LCB_STS_ROUND_TRIP_LTP_CNT, &tmp);
991
992
993
994
995
996 if (tmp > 0xff)
997 tmp = 0xff;
998 pi->replay_depth.wire = tmp;
999
1000 if (resp_len)
1001 *resp_len += sizeof(struct opa_port_info);
1002
1003 return reply((struct ib_mad_hdr *)smp);
1004}
1005
1006
1007
1008
1009
1010
1011
1012static int get_pkeys(struct hfi1_devdata *dd, u32 port, u16 *pkeys)
1013{
1014 struct hfi1_pportdata *ppd = dd->pport + port - 1;
1015
1016 memcpy(pkeys, ppd->pkeys, sizeof(ppd->pkeys));
1017
1018 return 0;
1019}
1020
1021static int __subn_get_opa_pkeytable(struct opa_smp *smp, u32 am, u8 *data,
1022 struct ib_device *ibdev, u32 port,
1023 u32 *resp_len, u32 max_len)
1024{
1025 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
1026 u32 n_blocks_req = OPA_AM_NBLK(am);
1027 u32 start_block = am & 0x7ff;
1028 __be16 *p;
1029 u16 *q;
1030 int i;
1031 u16 n_blocks_avail;
1032 unsigned npkeys = hfi1_get_npkeys(dd);
1033 size_t size;
1034
1035 if (n_blocks_req == 0) {
1036 pr_warn("OPA Get PKey AM Invalid : P = %d; B = 0x%x; N = 0x%x\n",
1037 port, start_block, n_blocks_req);
1038 smp->status |= IB_SMP_INVALID_FIELD;
1039 return reply((struct ib_mad_hdr *)smp);
1040 }
1041
1042 n_blocks_avail = (u16)(npkeys / OPA_PARTITION_TABLE_BLK_SIZE) + 1;
1043
1044 size = (n_blocks_req * OPA_PARTITION_TABLE_BLK_SIZE) * sizeof(u16);
1045
1046 if (smp_length_check(size, max_len)) {
1047 smp->status |= IB_SMP_INVALID_FIELD;
1048 return reply((struct ib_mad_hdr *)smp);
1049 }
1050
1051 if (start_block + n_blocks_req > n_blocks_avail ||
1052 n_blocks_req > OPA_NUM_PKEY_BLOCKS_PER_SMP) {
1053 pr_warn("OPA Get PKey AM Invalid : s 0x%x; req 0x%x; "
1054 "avail 0x%x; blk/smp 0x%lx\n",
1055 start_block, n_blocks_req, n_blocks_avail,
1056 OPA_NUM_PKEY_BLOCKS_PER_SMP);
1057 smp->status |= IB_SMP_INVALID_FIELD;
1058 return reply((struct ib_mad_hdr *)smp);
1059 }
1060
1061 p = (__be16 *)data;
1062 q = (u16 *)data;
1063
1064 if (start_block == 0) {
1065 get_pkeys(dd, port, q);
1066 for (i = 0; i < npkeys; i++)
1067 p[i] = cpu_to_be16(q[i]);
1068 if (resp_len)
1069 *resp_len += size;
1070 } else {
1071 smp->status |= IB_SMP_INVALID_FIELD;
1072 }
1073 return reply((struct ib_mad_hdr *)smp);
1074}
1075
1076enum {
1077 HFI_TRANSITION_DISALLOWED,
1078 HFI_TRANSITION_IGNORED,
1079 HFI_TRANSITION_ALLOWED,
1080 HFI_TRANSITION_UNDEFINED,
1081};
1082
1083
1084
1085
1086
1087enum {
1088 __D = HFI_TRANSITION_DISALLOWED,
1089 __I = HFI_TRANSITION_IGNORED,
1090 __A = HFI_TRANSITION_ALLOWED,
1091 __U = HFI_TRANSITION_UNDEFINED,
1092};
1093
1094
1095
1096
1097
1098#define __N_PHYSTATES (OPA_PORTPHYSSTATE_MAX - IB_PORTPHYSSTATE_POLLING + 1)
1099
1100
1101
1102
1103
1104
1105
1106static const struct {
1107 u8 allowed[__N_PHYSTATES][__N_PHYSTATES];
1108} physical_state_transitions = {
1109 {
1110
1111 { __A, __A, __D, __D, __D, __D, __D, __D, __D, __D },
1112 { __A, __I, __D, __D, __D, __D, __D, __D, __D, __A },
1113 { __U, __U, __U, __U, __U, __U, __U, __U, __U, __U },
1114 { __A, __A, __D, __I, __D, __D, __D, __D, __D, __D },
1115 { __U, __U, __U, __U, __U, __U, __U, __U, __U, __U },
1116 { __D, __A, __D, __D, __D, __I, __D, __D, __D, __D },
1117 { __U, __U, __U, __U, __U, __U, __U, __U, __U, __U },
1118 { __I, __A, __D, __D, __D, __D, __D, __I, __D, __D },
1119 { __U, __U, __U, __U, __U, __U, __U, __U, __U, __U },
1120 { __D, __A, __D, __D, __D, __D, __D, __D, __D, __I },
1121 }
1122};
1123
1124
1125
1126
1127
1128
1129#define __N_LOGICAL_STATES (IB_PORT_ACTIVE_DEFER - IB_PORT_DOWN + 1)
1130
1131
1132
1133
1134
1135
1136
1137static const struct {
1138 u8 allowed[__N_LOGICAL_STATES][__N_LOGICAL_STATES];
1139} logical_state_transitions = {
1140 {
1141
1142 { __I, __D, __D, __D, __U},
1143 { __D, __I, __A, __D, __U},
1144 { __D, __D, __I, __A, __U},
1145 { __D, __D, __I, __I, __U},
1146 { __U, __U, __U, __U, __U},
1147 }
1148};
1149
1150static int logical_transition_allowed(int old, int new)
1151{
1152 if (old < IB_PORT_NOP || old > IB_PORT_ACTIVE_DEFER ||
1153 new < IB_PORT_NOP || new > IB_PORT_ACTIVE_DEFER) {
1154 pr_warn("invalid logical state(s) (old %d new %d)\n",
1155 old, new);
1156 return HFI_TRANSITION_UNDEFINED;
1157 }
1158
1159 if (new == IB_PORT_NOP)
1160 return HFI_TRANSITION_ALLOWED;
1161
1162
1163 old -= IB_PORT_DOWN;
1164 new -= IB_PORT_DOWN;
1165
1166 if (old < 0 || new < 0)
1167 return HFI_TRANSITION_UNDEFINED;
1168 return logical_state_transitions.allowed[old][new];
1169}
1170
1171static int physical_transition_allowed(int old, int new)
1172{
1173 if (old < IB_PORTPHYSSTATE_NOP || old > OPA_PORTPHYSSTATE_MAX ||
1174 new < IB_PORTPHYSSTATE_NOP || new > OPA_PORTPHYSSTATE_MAX) {
1175 pr_warn("invalid physical state(s) (old %d new %d)\n",
1176 old, new);
1177 return HFI_TRANSITION_UNDEFINED;
1178 }
1179
1180 if (new == IB_PORTPHYSSTATE_NOP)
1181 return HFI_TRANSITION_ALLOWED;
1182
1183
1184 old -= IB_PORTPHYSSTATE_POLLING;
1185 new -= IB_PORTPHYSSTATE_POLLING;
1186
1187 if (old < 0 || new < 0)
1188 return HFI_TRANSITION_UNDEFINED;
1189 return physical_state_transitions.allowed[old][new];
1190}
1191
1192static int port_states_transition_allowed(struct hfi1_pportdata *ppd,
1193 u32 logical_new, u32 physical_new)
1194{
1195 u32 physical_old = driver_pstate(ppd);
1196 u32 logical_old = driver_lstate(ppd);
1197 int ret, logical_allowed, physical_allowed;
1198
1199 ret = logical_transition_allowed(logical_old, logical_new);
1200 logical_allowed = ret;
1201
1202 if (ret == HFI_TRANSITION_DISALLOWED ||
1203 ret == HFI_TRANSITION_UNDEFINED) {
1204 pr_warn("invalid logical state transition %s -> %s\n",
1205 opa_lstate_name(logical_old),
1206 opa_lstate_name(logical_new));
1207 return ret;
1208 }
1209
1210 ret = physical_transition_allowed(physical_old, physical_new);
1211 physical_allowed = ret;
1212
1213 if (ret == HFI_TRANSITION_DISALLOWED ||
1214 ret == HFI_TRANSITION_UNDEFINED) {
1215 pr_warn("invalid physical state transition %s -> %s\n",
1216 opa_pstate_name(physical_old),
1217 opa_pstate_name(physical_new));
1218 return ret;
1219 }
1220
1221 if (logical_allowed == HFI_TRANSITION_IGNORED &&
1222 physical_allowed == HFI_TRANSITION_IGNORED)
1223 return HFI_TRANSITION_IGNORED;
1224
1225
1226
1227
1228
1229 if ((physical_old == OPA_PORTPHYSSTATE_OFFLINE) &&
1230 (physical_new == IB_PORTPHYSSTATE_POLLING))
1231 return HFI_TRANSITION_IGNORED;
1232
1233
1234
1235
1236
1237 return HFI_TRANSITION_ALLOWED;
1238}
1239
1240static int set_port_states(struct hfi1_pportdata *ppd, struct opa_smp *smp,
1241 u32 logical_state, u32 phys_state, int local_mad)
1242{
1243 struct hfi1_devdata *dd = ppd->dd;
1244 u32 link_state;
1245 int ret;
1246
1247 ret = port_states_transition_allowed(ppd, logical_state, phys_state);
1248 if (ret == HFI_TRANSITION_DISALLOWED ||
1249 ret == HFI_TRANSITION_UNDEFINED) {
1250
1251 smp->status |= IB_SMP_INVALID_FIELD;
1252 return 0;
1253 }
1254
1255 if (ret == HFI_TRANSITION_IGNORED)
1256 return 0;
1257
1258 if ((phys_state != IB_PORTPHYSSTATE_NOP) &&
1259 !(logical_state == IB_PORT_DOWN ||
1260 logical_state == IB_PORT_NOP)){
1261 pr_warn("SubnSet(OPA_PortInfo) port state invalid: logical_state 0x%x physical_state 0x%x\n",
1262 logical_state, phys_state);
1263 smp->status |= IB_SMP_INVALID_FIELD;
1264 }
1265
1266
1267
1268
1269
1270
1271 switch (logical_state) {
1272 case IB_PORT_NOP:
1273 if (phys_state == IB_PORTPHYSSTATE_NOP)
1274 break;
1275 fallthrough;
1276 case IB_PORT_DOWN:
1277 if (phys_state == IB_PORTPHYSSTATE_NOP) {
1278 link_state = HLS_DN_DOWNDEF;
1279 } else if (phys_state == IB_PORTPHYSSTATE_POLLING) {
1280 link_state = HLS_DN_POLL;
1281 set_link_down_reason(ppd, OPA_LINKDOWN_REASON_FM_BOUNCE,
1282 0, OPA_LINKDOWN_REASON_FM_BOUNCE);
1283 } else if (phys_state == IB_PORTPHYSSTATE_DISABLED) {
1284 link_state = HLS_DN_DISABLE;
1285 } else {
1286 pr_warn("SubnSet(OPA_PortInfo) invalid physical state 0x%x\n",
1287 phys_state);
1288 smp->status |= IB_SMP_INVALID_FIELD;
1289 break;
1290 }
1291
1292 if ((link_state == HLS_DN_POLL ||
1293 link_state == HLS_DN_DOWNDEF)) {
1294
1295
1296
1297
1298
1299
1300
1301 set_link_state(ppd, HLS_DN_OFFLINE);
1302 start_link(ppd);
1303 } else {
1304 set_link_state(ppd, link_state);
1305 }
1306 if (link_state == HLS_DN_DISABLE &&
1307 (ppd->offline_disabled_reason >
1308 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_SMA_DISABLED) ||
1309 ppd->offline_disabled_reason ==
1310 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_NONE)))
1311 ppd->offline_disabled_reason =
1312 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_SMA_DISABLED);
1313
1314
1315
1316
1317 if (link_state == HLS_DN_DISABLE && !local_mad)
1318 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
1319 break;
1320 case IB_PORT_ARMED:
1321 ret = set_link_state(ppd, HLS_UP_ARMED);
1322 if (!ret)
1323 send_idle_sma(dd, SMA_IDLE_ARM);
1324 break;
1325 case IB_PORT_ACTIVE:
1326 if (ppd->neighbor_normal) {
1327 ret = set_link_state(ppd, HLS_UP_ACTIVE);
1328 if (ret == 0)
1329 send_idle_sma(dd, SMA_IDLE_ACTIVE);
1330 } else {
1331 pr_warn("SubnSet(OPA_PortInfo) Cannot move to Active with NeighborNormal 0\n");
1332 smp->status |= IB_SMP_INVALID_FIELD;
1333 }
1334 break;
1335 default:
1336 pr_warn("SubnSet(OPA_PortInfo) invalid logical state 0x%x\n",
1337 logical_state);
1338 smp->status |= IB_SMP_INVALID_FIELD;
1339 }
1340
1341 return 0;
1342}
1343
1344
1345
1346
1347
1348
1349
1350
1351static int __subn_set_opa_portinfo(struct opa_smp *smp, u32 am, u8 *data,
1352 struct ib_device *ibdev, u32 port,
1353 u32 *resp_len, u32 max_len, int local_mad)
1354{
1355 struct opa_port_info *pi = (struct opa_port_info *)data;
1356 struct ib_event event;
1357 struct hfi1_devdata *dd;
1358 struct hfi1_pportdata *ppd;
1359 struct hfi1_ibport *ibp;
1360 u8 clientrereg;
1361 unsigned long flags;
1362 u32 smlid;
1363 u32 lid;
1364 u8 ls_old, ls_new, ps_new;
1365 u8 vls;
1366 u8 msl;
1367 u8 crc_enabled;
1368 u16 lse, lwe, mtu;
1369 u32 num_ports = OPA_AM_NPORT(am);
1370 u32 start_of_sm_config = OPA_AM_START_SM_CFG(am);
1371 int ret, i, invalid = 0, call_set_mtu = 0;
1372 int call_link_downgrade_policy = 0;
1373
1374 if (num_ports != 1 ||
1375 smp_length_check(sizeof(*pi), max_len)) {
1376 smp->status |= IB_SMP_INVALID_FIELD;
1377 return reply((struct ib_mad_hdr *)smp);
1378 }
1379
1380 lid = be32_to_cpu(pi->lid);
1381 if (lid & 0xFF000000) {
1382 pr_warn("OPA_PortInfo lid out of range: %X\n", lid);
1383 smp->status |= IB_SMP_INVALID_FIELD;
1384 goto get_only;
1385 }
1386
1387
1388 smlid = be32_to_cpu(pi->sm_lid);
1389 if (smlid & 0xFF000000) {
1390 pr_warn("OPA_PortInfo SM lid out of range: %X\n", smlid);
1391 smp->status |= IB_SMP_INVALID_FIELD;
1392 goto get_only;
1393 }
1394
1395 clientrereg = (pi->clientrereg_subnettimeout &
1396 OPA_PI_MASK_CLIENT_REREGISTER);
1397
1398 dd = dd_from_ibdev(ibdev);
1399
1400 ppd = dd->pport + (port - 1);
1401 ibp = &ppd->ibport_data;
1402 event.device = ibdev;
1403 event.element.port_num = port;
1404
1405 ls_old = driver_lstate(ppd);
1406
1407 ibp->rvp.mkey = pi->mkey;
1408 if (ibp->rvp.gid_prefix != pi->subnet_prefix) {
1409 ibp->rvp.gid_prefix = pi->subnet_prefix;
1410 event.event = IB_EVENT_GID_CHANGE;
1411 ib_dispatch_event(&event);
1412 }
1413 ibp->rvp.mkey_lease_period = be16_to_cpu(pi->mkey_lease_period);
1414
1415
1416 if ((lid == 0 && ls_old > IB_PORT_INIT) ||
1417 (hfi1_is_16B_mcast(lid))) {
1418 smp->status |= IB_SMP_INVALID_FIELD;
1419 pr_warn("SubnSet(OPA_PortInfo) lid invalid 0x%x\n",
1420 lid);
1421 } else if (ppd->lid != lid ||
1422 ppd->lmc != (pi->mkeyprotect_lmc & OPA_PI_MASK_LMC)) {
1423 if (ppd->lid != lid)
1424 hfi1_set_uevent_bits(ppd, _HFI1_EVENT_LID_CHANGE_BIT);
1425 if (ppd->lmc != (pi->mkeyprotect_lmc & OPA_PI_MASK_LMC))
1426 hfi1_set_uevent_bits(ppd, _HFI1_EVENT_LMC_CHANGE_BIT);
1427 hfi1_set_lid(ppd, lid, pi->mkeyprotect_lmc & OPA_PI_MASK_LMC);
1428 event.event = IB_EVENT_LID_CHANGE;
1429 ib_dispatch_event(&event);
1430
1431 if (HFI1_PORT_GUID_INDEX + 1 < HFI1_GUIDS_PER_PORT) {
1432
1433
1434
1435 ppd->guids[HFI1_PORT_GUID_INDEX + 1] =
1436 be64_to_cpu(OPA_MAKE_ID(lid));
1437 event.event = IB_EVENT_GID_CHANGE;
1438 ib_dispatch_event(&event);
1439 }
1440 }
1441
1442 msl = pi->smsl & OPA_PI_MASK_SMSL;
1443 if (pi->partenforce_filterraw & OPA_PI_MASK_LINKINIT_REASON)
1444 ppd->linkinit_reason =
1445 (pi->partenforce_filterraw &
1446 OPA_PI_MASK_LINKINIT_REASON);
1447
1448
1449 if ((smlid == 0 && ls_old > IB_PORT_INIT) ||
1450 (hfi1_is_16B_mcast(smlid))) {
1451 smp->status |= IB_SMP_INVALID_FIELD;
1452 pr_warn("SubnSet(OPA_PortInfo) smlid invalid 0x%x\n", smlid);
1453 } else if (smlid != ibp->rvp.sm_lid || msl != ibp->rvp.sm_sl) {
1454 pr_warn("SubnSet(OPA_PortInfo) smlid 0x%x\n", smlid);
1455 spin_lock_irqsave(&ibp->rvp.lock, flags);
1456 if (ibp->rvp.sm_ah) {
1457 if (smlid != ibp->rvp.sm_lid)
1458 hfi1_modify_qp0_ah(ibp, ibp->rvp.sm_ah, smlid);
1459 if (msl != ibp->rvp.sm_sl)
1460 rdma_ah_set_sl(&ibp->rvp.sm_ah->attr, msl);
1461 }
1462 spin_unlock_irqrestore(&ibp->rvp.lock, flags);
1463 if (smlid != ibp->rvp.sm_lid)
1464 ibp->rvp.sm_lid = smlid;
1465 if (msl != ibp->rvp.sm_sl)
1466 ibp->rvp.sm_sl = msl;
1467 event.event = IB_EVENT_SM_CHANGE;
1468 ib_dispatch_event(&event);
1469 }
1470
1471 if (pi->link_down_reason == 0) {
1472 ppd->local_link_down_reason.sma = 0;
1473 ppd->local_link_down_reason.latest = 0;
1474 }
1475
1476 if (pi->neigh_link_down_reason == 0) {
1477 ppd->neigh_link_down_reason.sma = 0;
1478 ppd->neigh_link_down_reason.latest = 0;
1479 }
1480
1481 ppd->sm_trap_qp = be32_to_cpu(pi->sm_trap_qp);
1482 ppd->sa_qp = be32_to_cpu(pi->sa_qp);
1483
1484 ppd->port_error_action = be32_to_cpu(pi->port_error_action);
1485 lwe = be16_to_cpu(pi->link_width.enabled);
1486 if (lwe) {
1487 if (lwe == OPA_LINK_WIDTH_RESET ||
1488 lwe == OPA_LINK_WIDTH_RESET_OLD)
1489 set_link_width_enabled(ppd, ppd->link_width_supported);
1490 else if ((lwe & ~ppd->link_width_supported) == 0)
1491 set_link_width_enabled(ppd, lwe);
1492 else
1493 smp->status |= IB_SMP_INVALID_FIELD;
1494 }
1495 lwe = be16_to_cpu(pi->link_width_downgrade.enabled);
1496
1497 if (lwe == OPA_LINK_WIDTH_RESET ||
1498 lwe == OPA_LINK_WIDTH_RESET_OLD) {
1499 set_link_width_downgrade_enabled(ppd,
1500 ppd->
1501 link_width_downgrade_supported
1502 );
1503 } else if ((lwe & ~ppd->link_width_downgrade_supported) == 0) {
1504
1505 if (lwe != ppd->link_width_downgrade_enabled) {
1506 set_link_width_downgrade_enabled(ppd, lwe);
1507 call_link_downgrade_policy = 1;
1508 }
1509 } else {
1510 smp->status |= IB_SMP_INVALID_FIELD;
1511 }
1512 lse = be16_to_cpu(pi->link_speed.enabled);
1513 if (lse) {
1514 if (lse & be16_to_cpu(pi->link_speed.supported))
1515 set_link_speed_enabled(ppd, lse);
1516 else
1517 smp->status |= IB_SMP_INVALID_FIELD;
1518 }
1519
1520 ibp->rvp.mkeyprot =
1521 (pi->mkeyprotect_lmc & OPA_PI_MASK_MKEY_PROT_BIT) >> 6;
1522 ibp->rvp.vl_high_limit = be16_to_cpu(pi->vl.high_limit) & 0xFF;
1523 (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_VL_HIGH_LIMIT,
1524 ibp->rvp.vl_high_limit);
1525
1526 if (ppd->vls_supported / 2 > ARRAY_SIZE(pi->neigh_mtu.pvlx_to_mtu) ||
1527 ppd->vls_supported > ARRAY_SIZE(dd->vld)) {
1528 smp->status |= IB_SMP_INVALID_FIELD;
1529 return reply((struct ib_mad_hdr *)smp);
1530 }
1531 for (i = 0; i < ppd->vls_supported; i++) {
1532 if ((i % 2) == 0)
1533 mtu = enum_to_mtu((pi->neigh_mtu.pvlx_to_mtu[i / 2] >>
1534 4) & 0xF);
1535 else
1536 mtu = enum_to_mtu(pi->neigh_mtu.pvlx_to_mtu[i / 2] &
1537 0xF);
1538 if (mtu == 0xffff) {
1539 pr_warn("SubnSet(OPA_PortInfo) mtu invalid %d (0x%x)\n",
1540 mtu,
1541 (pi->neigh_mtu.pvlx_to_mtu[0] >> 4) & 0xF);
1542 smp->status |= IB_SMP_INVALID_FIELD;
1543 mtu = hfi1_max_mtu;
1544 }
1545 if (dd->vld[i].mtu != mtu) {
1546 dd_dev_info(dd,
1547 "MTU change on vl %d from %d to %d\n",
1548 i, dd->vld[i].mtu, mtu);
1549 dd->vld[i].mtu = mtu;
1550 call_set_mtu++;
1551 }
1552 }
1553
1554
1555
1556 mtu = enum_to_mtu(pi->neigh_mtu.pvlx_to_mtu[15 / 2] & 0xF);
1557 if (mtu < 2048 || mtu == 0xffff)
1558 mtu = 2048;
1559 if (dd->vld[15].mtu != mtu) {
1560 dd_dev_info(dd,
1561 "MTU change on vl 15 from %d to %d\n",
1562 dd->vld[15].mtu, mtu);
1563 dd->vld[15].mtu = mtu;
1564 call_set_mtu++;
1565 }
1566 if (call_set_mtu)
1567 set_mtu(ppd);
1568
1569
1570 vls = pi->operational_vls & OPA_PI_MASK_OPERATIONAL_VL;
1571 if (vls) {
1572 if (vls > ppd->vls_supported) {
1573 pr_warn("SubnSet(OPA_PortInfo) VL's supported invalid %d\n",
1574 pi->operational_vls);
1575 smp->status |= IB_SMP_INVALID_FIELD;
1576 } else {
1577 if (hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_OP_VLS,
1578 vls) == -EINVAL)
1579 smp->status |= IB_SMP_INVALID_FIELD;
1580 }
1581 }
1582
1583 if (pi->mkey_violations == 0)
1584 ibp->rvp.mkey_violations = 0;
1585
1586 if (pi->pkey_violations == 0)
1587 ibp->rvp.pkey_violations = 0;
1588
1589 if (pi->qkey_violations == 0)
1590 ibp->rvp.qkey_violations = 0;
1591
1592 ibp->rvp.subnet_timeout =
1593 pi->clientrereg_subnettimeout & OPA_PI_MASK_SUBNET_TIMEOUT;
1594
1595 crc_enabled = be16_to_cpu(pi->port_ltp_crc_mode);
1596 crc_enabled >>= 4;
1597 crc_enabled &= 0xf;
1598
1599 if (crc_enabled != 0)
1600 ppd->port_crc_mode_enabled = port_ltp_to_cap(crc_enabled);
1601
1602 ppd->is_active_optimize_enabled =
1603 !!(be16_to_cpu(pi->port_mode)
1604 & OPA_PI_MASK_PORT_ACTIVE_OPTOMIZE);
1605
1606 ls_new = pi->port_states.portphysstate_portstate &
1607 OPA_PI_MASK_PORT_STATE;
1608 ps_new = (pi->port_states.portphysstate_portstate &
1609 OPA_PI_MASK_PORT_PHYSICAL_STATE) >> 4;
1610
1611 if (ls_old == IB_PORT_INIT) {
1612 if (start_of_sm_config) {
1613 if (ls_new == ls_old || (ls_new == IB_PORT_ARMED))
1614 ppd->is_sm_config_started = 1;
1615 } else if (ls_new == IB_PORT_ARMED) {
1616 if (ppd->is_sm_config_started == 0) {
1617 invalid = 1;
1618 smp->status |= IB_SMP_INVALID_FIELD;
1619 }
1620 }
1621 }
1622
1623
1624 if (clientrereg) {
1625 event.event = IB_EVENT_CLIENT_REREGISTER;
1626 ib_dispatch_event(&event);
1627 }
1628
1629
1630
1631
1632
1633
1634
1635
1636 if (!invalid) {
1637 ret = set_port_states(ppd, smp, ls_new, ps_new, local_mad);
1638 if (ret)
1639 return ret;
1640 }
1641
1642 ret = __subn_get_opa_portinfo(smp, am, data, ibdev, port, resp_len,
1643 max_len);
1644
1645
1646 pi->clientrereg_subnettimeout |= clientrereg;
1647
1648
1649
1650
1651
1652
1653
1654 if (call_link_downgrade_policy)
1655 apply_link_downgrade_policy(ppd, 0);
1656
1657 return ret;
1658
1659get_only:
1660 return __subn_get_opa_portinfo(smp, am, data, ibdev, port, resp_len,
1661 max_len);
1662}
1663
1664
1665
1666
1667
1668
1669
1670static int set_pkeys(struct hfi1_devdata *dd, u32 port, u16 *pkeys)
1671{
1672 struct hfi1_pportdata *ppd;
1673 int i;
1674 int changed = 0;
1675 int update_includes_mgmt_partition = 0;
1676
1677
1678
1679
1680
1681
1682
1683 ppd = dd->pport + (port - 1);
1684
1685
1686
1687 for (i = 0; i < ARRAY_SIZE(ppd->pkeys); i++) {
1688 if (pkeys[i] == LIM_MGMT_P_KEY) {
1689 update_includes_mgmt_partition = 1;
1690 break;
1691 }
1692 }
1693
1694 if (!update_includes_mgmt_partition)
1695 return 1;
1696
1697 for (i = 0; i < ARRAY_SIZE(ppd->pkeys); i++) {
1698 u16 key = pkeys[i];
1699 u16 okey = ppd->pkeys[i];
1700
1701 if (key == okey)
1702 continue;
1703
1704
1705
1706
1707
1708 ppd->pkeys[i] = key;
1709 changed = 1;
1710 }
1711
1712 if (changed) {
1713 (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
1714 hfi1_event_pkey_change(dd, port);
1715 }
1716
1717 return 0;
1718}
1719
1720static int __subn_set_opa_pkeytable(struct opa_smp *smp, u32 am, u8 *data,
1721 struct ib_device *ibdev, u32 port,
1722 u32 *resp_len, u32 max_len)
1723{
1724 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
1725 u32 n_blocks_sent = OPA_AM_NBLK(am);
1726 u32 start_block = am & 0x7ff;
1727 u16 *p = (u16 *)data;
1728 __be16 *q = (__be16 *)data;
1729 int i;
1730 u16 n_blocks_avail;
1731 unsigned npkeys = hfi1_get_npkeys(dd);
1732 u32 size = 0;
1733
1734 if (n_blocks_sent == 0) {
1735 pr_warn("OPA Get PKey AM Invalid : P = %u; B = 0x%x; N = 0x%x\n",
1736 port, start_block, n_blocks_sent);
1737 smp->status |= IB_SMP_INVALID_FIELD;
1738 return reply((struct ib_mad_hdr *)smp);
1739 }
1740
1741 n_blocks_avail = (u16)(npkeys / OPA_PARTITION_TABLE_BLK_SIZE) + 1;
1742
1743 size = sizeof(u16) * (n_blocks_sent * OPA_PARTITION_TABLE_BLK_SIZE);
1744
1745 if (smp_length_check(size, max_len)) {
1746 smp->status |= IB_SMP_INVALID_FIELD;
1747 return reply((struct ib_mad_hdr *)smp);
1748 }
1749
1750 if (start_block + n_blocks_sent > n_blocks_avail ||
1751 n_blocks_sent > OPA_NUM_PKEY_BLOCKS_PER_SMP) {
1752 pr_warn("OPA Set PKey AM Invalid : s 0x%x; req 0x%x; avail 0x%x; blk/smp 0x%lx\n",
1753 start_block, n_blocks_sent, n_blocks_avail,
1754 OPA_NUM_PKEY_BLOCKS_PER_SMP);
1755 smp->status |= IB_SMP_INVALID_FIELD;
1756 return reply((struct ib_mad_hdr *)smp);
1757 }
1758
1759 for (i = 0; i < n_blocks_sent * OPA_PARTITION_TABLE_BLK_SIZE; i++)
1760 p[i] = be16_to_cpu(q[i]);
1761
1762 if (start_block == 0 && set_pkeys(dd, port, p) != 0) {
1763 smp->status |= IB_SMP_INVALID_FIELD;
1764 return reply((struct ib_mad_hdr *)smp);
1765 }
1766
1767 return __subn_get_opa_pkeytable(smp, am, data, ibdev, port, resp_len,
1768 max_len);
1769}
1770
1771#define ILLEGAL_VL 12
1772
1773
1774
1775
1776
1777
1778
1779static void filter_sc2vlt(void *data, bool set)
1780{
1781 int i;
1782 u8 *pd = data;
1783
1784 for (i = 0; i < OPA_MAX_SCS; i++) {
1785 if (i == 15)
1786 continue;
1787
1788 if (set) {
1789 if ((pd[i] & 0x1f) == 0xf)
1790 pd[i] = ILLEGAL_VL;
1791 } else {
1792 if ((pd[i] & 0x1f) == ILLEGAL_VL)
1793 pd[i] = 0xf;
1794 }
1795 }
1796}
1797
1798static int set_sc2vlt_tables(struct hfi1_devdata *dd, void *data)
1799{
1800 u64 *val = data;
1801
1802 filter_sc2vlt(data, true);
1803
1804 write_csr(dd, SEND_SC2VLT0, *val++);
1805 write_csr(dd, SEND_SC2VLT1, *val++);
1806 write_csr(dd, SEND_SC2VLT2, *val++);
1807 write_csr(dd, SEND_SC2VLT3, *val++);
1808 write_seqlock_irq(&dd->sc2vl_lock);
1809 memcpy(dd->sc2vl, data, sizeof(dd->sc2vl));
1810 write_sequnlock_irq(&dd->sc2vl_lock);
1811 return 0;
1812}
1813
1814static int get_sc2vlt_tables(struct hfi1_devdata *dd, void *data)
1815{
1816 u64 *val = (u64 *)data;
1817
1818 *val++ = read_csr(dd, SEND_SC2VLT0);
1819 *val++ = read_csr(dd, SEND_SC2VLT1);
1820 *val++ = read_csr(dd, SEND_SC2VLT2);
1821 *val++ = read_csr(dd, SEND_SC2VLT3);
1822
1823 filter_sc2vlt((u64 *)data, false);
1824 return 0;
1825}
1826
1827static int __subn_get_opa_sl_to_sc(struct opa_smp *smp, u32 am, u8 *data,
1828 struct ib_device *ibdev, u32 port,
1829 u32 *resp_len, u32 max_len)
1830{
1831 struct hfi1_ibport *ibp = to_iport(ibdev, port);
1832 u8 *p = data;
1833 size_t size = ARRAY_SIZE(ibp->sl_to_sc);
1834 unsigned i;
1835
1836 if (am || smp_length_check(size, max_len)) {
1837 smp->status |= IB_SMP_INVALID_FIELD;
1838 return reply((struct ib_mad_hdr *)smp);
1839 }
1840
1841 for (i = 0; i < ARRAY_SIZE(ibp->sl_to_sc); i++)
1842 *p++ = ibp->sl_to_sc[i];
1843
1844 if (resp_len)
1845 *resp_len += size;
1846
1847 return reply((struct ib_mad_hdr *)smp);
1848}
1849
1850static int __subn_set_opa_sl_to_sc(struct opa_smp *smp, u32 am, u8 *data,
1851 struct ib_device *ibdev, u32 port,
1852 u32 *resp_len, u32 max_len)
1853{
1854 struct hfi1_ibport *ibp = to_iport(ibdev, port);
1855 u8 *p = data;
1856 size_t size = ARRAY_SIZE(ibp->sl_to_sc);
1857 int i;
1858 u8 sc;
1859
1860 if (am || smp_length_check(size, max_len)) {
1861 smp->status |= IB_SMP_INVALID_FIELD;
1862 return reply((struct ib_mad_hdr *)smp);
1863 }
1864
1865 for (i = 0; i < ARRAY_SIZE(ibp->sl_to_sc); i++) {
1866 sc = *p++;
1867 if (ibp->sl_to_sc[i] != sc) {
1868 ibp->sl_to_sc[i] = sc;
1869
1870
1871 hfi1_error_port_qps(ibp, i);
1872 }
1873 }
1874
1875 return __subn_get_opa_sl_to_sc(smp, am, data, ibdev, port, resp_len,
1876 max_len);
1877}
1878
1879static int __subn_get_opa_sc_to_sl(struct opa_smp *smp, u32 am, u8 *data,
1880 struct ib_device *ibdev, u32 port,
1881 u32 *resp_len, u32 max_len)
1882{
1883 struct hfi1_ibport *ibp = to_iport(ibdev, port);
1884 u8 *p = data;
1885 size_t size = ARRAY_SIZE(ibp->sc_to_sl);
1886 unsigned i;
1887
1888 if (am || smp_length_check(size, max_len)) {
1889 smp->status |= IB_SMP_INVALID_FIELD;
1890 return reply((struct ib_mad_hdr *)smp);
1891 }
1892
1893 for (i = 0; i < ARRAY_SIZE(ibp->sc_to_sl); i++)
1894 *p++ = ibp->sc_to_sl[i];
1895
1896 if (resp_len)
1897 *resp_len += size;
1898
1899 return reply((struct ib_mad_hdr *)smp);
1900}
1901
1902static int __subn_set_opa_sc_to_sl(struct opa_smp *smp, u32 am, u8 *data,
1903 struct ib_device *ibdev, u32 port,
1904 u32 *resp_len, u32 max_len)
1905{
1906 struct hfi1_ibport *ibp = to_iport(ibdev, port);
1907 size_t size = ARRAY_SIZE(ibp->sc_to_sl);
1908 u8 *p = data;
1909 int i;
1910
1911 if (am || smp_length_check(size, max_len)) {
1912 smp->status |= IB_SMP_INVALID_FIELD;
1913 return reply((struct ib_mad_hdr *)smp);
1914 }
1915
1916 for (i = 0; i < ARRAY_SIZE(ibp->sc_to_sl); i++)
1917 ibp->sc_to_sl[i] = *p++;
1918
1919 return __subn_get_opa_sc_to_sl(smp, am, data, ibdev, port, resp_len,
1920 max_len);
1921}
1922
1923static int __subn_get_opa_sc_to_vlt(struct opa_smp *smp, u32 am, u8 *data,
1924 struct ib_device *ibdev, u32 port,
1925 u32 *resp_len, u32 max_len)
1926{
1927 u32 n_blocks = OPA_AM_NBLK(am);
1928 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
1929 void *vp = (void *)data;
1930 size_t size = 4 * sizeof(u64);
1931
1932 if (n_blocks != 1 || smp_length_check(size, max_len)) {
1933 smp->status |= IB_SMP_INVALID_FIELD;
1934 return reply((struct ib_mad_hdr *)smp);
1935 }
1936
1937 get_sc2vlt_tables(dd, vp);
1938
1939 if (resp_len)
1940 *resp_len += size;
1941
1942 return reply((struct ib_mad_hdr *)smp);
1943}
1944
1945static int __subn_set_opa_sc_to_vlt(struct opa_smp *smp, u32 am, u8 *data,
1946 struct ib_device *ibdev, u32 port,
1947 u32 *resp_len, u32 max_len)
1948{
1949 u32 n_blocks = OPA_AM_NBLK(am);
1950 int async_update = OPA_AM_ASYNC(am);
1951 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
1952 void *vp = (void *)data;
1953 struct hfi1_pportdata *ppd;
1954 int lstate;
1955
1956
1957
1958
1959
1960
1961 size_t size = 4 * sizeof(u64);
1962
1963 if (n_blocks != 1 || async_update || smp_length_check(size, max_len)) {
1964 smp->status |= IB_SMP_INVALID_FIELD;
1965 return reply((struct ib_mad_hdr *)smp);
1966 }
1967
1968
1969 ppd = dd->pport + (port - 1);
1970 lstate = driver_lstate(ppd);
1971
1972
1973
1974
1975 if (!async_update &&
1976 (lstate == IB_PORT_ARMED || lstate == IB_PORT_ACTIVE)) {
1977 smp->status |= IB_SMP_INVALID_FIELD;
1978 return reply((struct ib_mad_hdr *)smp);
1979 }
1980
1981 set_sc2vlt_tables(dd, vp);
1982
1983 return __subn_get_opa_sc_to_vlt(smp, am, data, ibdev, port, resp_len,
1984 max_len);
1985}
1986
1987static int __subn_get_opa_sc_to_vlnt(struct opa_smp *smp, u32 am, u8 *data,
1988 struct ib_device *ibdev, u32 port,
1989 u32 *resp_len, u32 max_len)
1990{
1991 u32 n_blocks = OPA_AM_NPORT(am);
1992 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
1993 struct hfi1_pportdata *ppd;
1994 void *vp = (void *)data;
1995 int size = sizeof(struct sc2vlnt);
1996
1997 if (n_blocks != 1 || smp_length_check(size, max_len)) {
1998 smp->status |= IB_SMP_INVALID_FIELD;
1999 return reply((struct ib_mad_hdr *)smp);
2000 }
2001
2002 ppd = dd->pport + (port - 1);
2003
2004 fm_get_table(ppd, FM_TBL_SC2VLNT, vp);
2005
2006 if (resp_len)
2007 *resp_len += size;
2008
2009 return reply((struct ib_mad_hdr *)smp);
2010}
2011
2012static int __subn_set_opa_sc_to_vlnt(struct opa_smp *smp, u32 am, u8 *data,
2013 struct ib_device *ibdev, u32 port,
2014 u32 *resp_len, u32 max_len)
2015{
2016 u32 n_blocks = OPA_AM_NPORT(am);
2017 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2018 struct hfi1_pportdata *ppd;
2019 void *vp = (void *)data;
2020 int lstate;
2021 int size = sizeof(struct sc2vlnt);
2022
2023 if (n_blocks != 1 || smp_length_check(size, max_len)) {
2024 smp->status |= IB_SMP_INVALID_FIELD;
2025 return reply((struct ib_mad_hdr *)smp);
2026 }
2027
2028
2029 ppd = dd->pport + (port - 1);
2030 lstate = driver_lstate(ppd);
2031 if (lstate == IB_PORT_ARMED || lstate == IB_PORT_ACTIVE) {
2032 smp->status |= IB_SMP_INVALID_FIELD;
2033 return reply((struct ib_mad_hdr *)smp);
2034 }
2035
2036 ppd = dd->pport + (port - 1);
2037
2038 fm_set_table(ppd, FM_TBL_SC2VLNT, vp);
2039
2040 return __subn_get_opa_sc_to_vlnt(smp, am, data, ibdev, port,
2041 resp_len, max_len);
2042}
2043
2044static int __subn_get_opa_psi(struct opa_smp *smp, u32 am, u8 *data,
2045 struct ib_device *ibdev, u32 port,
2046 u32 *resp_len, u32 max_len)
2047{
2048 u32 nports = OPA_AM_NPORT(am);
2049 u32 start_of_sm_config = OPA_AM_START_SM_CFG(am);
2050 u32 lstate;
2051 struct hfi1_ibport *ibp;
2052 struct hfi1_pportdata *ppd;
2053 struct opa_port_state_info *psi = (struct opa_port_state_info *)data;
2054
2055 if (nports != 1 || smp_length_check(sizeof(*psi), max_len)) {
2056 smp->status |= IB_SMP_INVALID_FIELD;
2057 return reply((struct ib_mad_hdr *)smp);
2058 }
2059
2060 ibp = to_iport(ibdev, port);
2061 ppd = ppd_from_ibp(ibp);
2062
2063 lstate = driver_lstate(ppd);
2064
2065 if (start_of_sm_config && (lstate == IB_PORT_INIT))
2066 ppd->is_sm_config_started = 1;
2067
2068 psi->port_states.ledenable_offlinereason = ppd->neighbor_normal << 4;
2069 psi->port_states.ledenable_offlinereason |=
2070 ppd->is_sm_config_started << 5;
2071 psi->port_states.ledenable_offlinereason |=
2072 ppd->offline_disabled_reason;
2073
2074 psi->port_states.portphysstate_portstate =
2075 (driver_pstate(ppd) << 4) | (lstate & 0xf);
2076 psi->link_width_downgrade_tx_active =
2077 cpu_to_be16(ppd->link_width_downgrade_tx_active);
2078 psi->link_width_downgrade_rx_active =
2079 cpu_to_be16(ppd->link_width_downgrade_rx_active);
2080 if (resp_len)
2081 *resp_len += sizeof(struct opa_port_state_info);
2082
2083 return reply((struct ib_mad_hdr *)smp);
2084}
2085
2086static int __subn_set_opa_psi(struct opa_smp *smp, u32 am, u8 *data,
2087 struct ib_device *ibdev, u32 port,
2088 u32 *resp_len, u32 max_len, int local_mad)
2089{
2090 u32 nports = OPA_AM_NPORT(am);
2091 u32 start_of_sm_config = OPA_AM_START_SM_CFG(am);
2092 u32 ls_old;
2093 u8 ls_new, ps_new;
2094 struct hfi1_ibport *ibp;
2095 struct hfi1_pportdata *ppd;
2096 struct opa_port_state_info *psi = (struct opa_port_state_info *)data;
2097 int ret, invalid = 0;
2098
2099 if (nports != 1 || smp_length_check(sizeof(*psi), max_len)) {
2100 smp->status |= IB_SMP_INVALID_FIELD;
2101 return reply((struct ib_mad_hdr *)smp);
2102 }
2103
2104 ibp = to_iport(ibdev, port);
2105 ppd = ppd_from_ibp(ibp);
2106
2107 ls_old = driver_lstate(ppd);
2108
2109 ls_new = port_states_to_logical_state(&psi->port_states);
2110 ps_new = port_states_to_phys_state(&psi->port_states);
2111
2112 if (ls_old == IB_PORT_INIT) {
2113 if (start_of_sm_config) {
2114 if (ls_new == ls_old || (ls_new == IB_PORT_ARMED))
2115 ppd->is_sm_config_started = 1;
2116 } else if (ls_new == IB_PORT_ARMED) {
2117 if (ppd->is_sm_config_started == 0) {
2118 invalid = 1;
2119 smp->status |= IB_SMP_INVALID_FIELD;
2120 }
2121 }
2122 }
2123
2124 if (!invalid) {
2125 ret = set_port_states(ppd, smp, ls_new, ps_new, local_mad);
2126 if (ret)
2127 return ret;
2128 }
2129
2130 return __subn_get_opa_psi(smp, am, data, ibdev, port, resp_len,
2131 max_len);
2132}
2133
2134static int __subn_get_opa_cable_info(struct opa_smp *smp, u32 am, u8 *data,
2135 struct ib_device *ibdev, u32 port,
2136 u32 *resp_len, u32 max_len)
2137{
2138 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2139 u32 addr = OPA_AM_CI_ADDR(am);
2140 u32 len = OPA_AM_CI_LEN(am) + 1;
2141 int ret;
2142
2143 if (dd->pport->port_type != PORT_TYPE_QSFP ||
2144 smp_length_check(len, max_len)) {
2145 smp->status |= IB_SMP_INVALID_FIELD;
2146 return reply((struct ib_mad_hdr *)smp);
2147 }
2148
2149#define __CI_PAGE_SIZE BIT(7)
2150#define __CI_PAGE_MASK ~(__CI_PAGE_SIZE - 1)
2151#define __CI_PAGE_NUM(a) ((a) & __CI_PAGE_MASK)
2152
2153
2154
2155
2156
2157 if (addr >= 4096 ||
2158 (__CI_PAGE_NUM(addr) != __CI_PAGE_NUM(addr + len - 1))) {
2159 smp->status |= IB_SMP_INVALID_FIELD;
2160 return reply((struct ib_mad_hdr *)smp);
2161 }
2162
2163 ret = get_cable_info(dd, port, addr, len, data);
2164
2165 if (ret == -ENODEV) {
2166 smp->status |= IB_SMP_UNSUP_METH_ATTR;
2167 return reply((struct ib_mad_hdr *)smp);
2168 }
2169
2170
2171
2172
2173
2174
2175 if (ret < 0 && ret != -ERANGE) {
2176 smp->status |= IB_SMP_INVALID_FIELD;
2177 return reply((struct ib_mad_hdr *)smp);
2178 }
2179
2180 if (resp_len)
2181 *resp_len += len;
2182
2183 return reply((struct ib_mad_hdr *)smp);
2184}
2185
2186static int __subn_get_opa_bct(struct opa_smp *smp, u32 am, u8 *data,
2187 struct ib_device *ibdev, u32 port, u32 *resp_len,
2188 u32 max_len)
2189{
2190 u32 num_ports = OPA_AM_NPORT(am);
2191 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2192 struct hfi1_pportdata *ppd;
2193 struct buffer_control *p = (struct buffer_control *)data;
2194 int size = sizeof(struct buffer_control);
2195
2196 if (num_ports != 1 || smp_length_check(size, max_len)) {
2197 smp->status |= IB_SMP_INVALID_FIELD;
2198 return reply((struct ib_mad_hdr *)smp);
2199 }
2200
2201 ppd = dd->pport + (port - 1);
2202 fm_get_table(ppd, FM_TBL_BUFFER_CONTROL, p);
2203 trace_bct_get(dd, p);
2204 if (resp_len)
2205 *resp_len += size;
2206
2207 return reply((struct ib_mad_hdr *)smp);
2208}
2209
2210static int __subn_set_opa_bct(struct opa_smp *smp, u32 am, u8 *data,
2211 struct ib_device *ibdev, u32 port, u32 *resp_len,
2212 u32 max_len)
2213{
2214 u32 num_ports = OPA_AM_NPORT(am);
2215 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2216 struct hfi1_pportdata *ppd;
2217 struct buffer_control *p = (struct buffer_control *)data;
2218
2219 if (num_ports != 1 || smp_length_check(sizeof(*p), max_len)) {
2220 smp->status |= IB_SMP_INVALID_FIELD;
2221 return reply((struct ib_mad_hdr *)smp);
2222 }
2223 ppd = dd->pport + (port - 1);
2224 trace_bct_set(dd, p);
2225 if (fm_set_table(ppd, FM_TBL_BUFFER_CONTROL, p) < 0) {
2226 smp->status |= IB_SMP_INVALID_FIELD;
2227 return reply((struct ib_mad_hdr *)smp);
2228 }
2229
2230 return __subn_get_opa_bct(smp, am, data, ibdev, port, resp_len,
2231 max_len);
2232}
2233
2234static int __subn_get_opa_vl_arb(struct opa_smp *smp, u32 am, u8 *data,
2235 struct ib_device *ibdev, u32 port,
2236 u32 *resp_len, u32 max_len)
2237{
2238 struct hfi1_pportdata *ppd = ppd_from_ibp(to_iport(ibdev, port));
2239 u32 num_ports = OPA_AM_NPORT(am);
2240 u8 section = (am & 0x00ff0000) >> 16;
2241 u8 *p = data;
2242 int size = 256;
2243
2244 if (num_ports != 1 || smp_length_check(size, max_len)) {
2245 smp->status |= IB_SMP_INVALID_FIELD;
2246 return reply((struct ib_mad_hdr *)smp);
2247 }
2248
2249 switch (section) {
2250 case OPA_VLARB_LOW_ELEMENTS:
2251 fm_get_table(ppd, FM_TBL_VL_LOW_ARB, p);
2252 break;
2253 case OPA_VLARB_HIGH_ELEMENTS:
2254 fm_get_table(ppd, FM_TBL_VL_HIGH_ARB, p);
2255 break;
2256 case OPA_VLARB_PREEMPT_ELEMENTS:
2257 fm_get_table(ppd, FM_TBL_VL_PREEMPT_ELEMS, p);
2258 break;
2259 case OPA_VLARB_PREEMPT_MATRIX:
2260 fm_get_table(ppd, FM_TBL_VL_PREEMPT_MATRIX, p);
2261 break;
2262 default:
2263 pr_warn("OPA SubnGet(VL Arb) AM Invalid : 0x%x\n",
2264 be32_to_cpu(smp->attr_mod));
2265 smp->status |= IB_SMP_INVALID_FIELD;
2266 size = 0;
2267 break;
2268 }
2269
2270 if (size > 0 && resp_len)
2271 *resp_len += size;
2272
2273 return reply((struct ib_mad_hdr *)smp);
2274}
2275
2276static int __subn_set_opa_vl_arb(struct opa_smp *smp, u32 am, u8 *data,
2277 struct ib_device *ibdev, u32 port,
2278 u32 *resp_len, u32 max_len)
2279{
2280 struct hfi1_pportdata *ppd = ppd_from_ibp(to_iport(ibdev, port));
2281 u32 num_ports = OPA_AM_NPORT(am);
2282 u8 section = (am & 0x00ff0000) >> 16;
2283 u8 *p = data;
2284 int size = 256;
2285
2286 if (num_ports != 1 || smp_length_check(size, max_len)) {
2287 smp->status |= IB_SMP_INVALID_FIELD;
2288 return reply((struct ib_mad_hdr *)smp);
2289 }
2290
2291 switch (section) {
2292 case OPA_VLARB_LOW_ELEMENTS:
2293 (void)fm_set_table(ppd, FM_TBL_VL_LOW_ARB, p);
2294 break;
2295 case OPA_VLARB_HIGH_ELEMENTS:
2296 (void)fm_set_table(ppd, FM_TBL_VL_HIGH_ARB, p);
2297 break;
2298
2299
2300
2301
2302 case OPA_VLARB_PREEMPT_ELEMENTS:
2303 case OPA_VLARB_PREEMPT_MATRIX:
2304 smp->status |= IB_SMP_UNSUP_METH_ATTR;
2305 break;
2306 default:
2307 pr_warn("OPA SubnSet(VL Arb) AM Invalid : 0x%x\n",
2308 be32_to_cpu(smp->attr_mod));
2309 smp->status |= IB_SMP_INVALID_FIELD;
2310 break;
2311 }
2312
2313 return __subn_get_opa_vl_arb(smp, am, data, ibdev, port, resp_len,
2314 max_len);
2315}
2316
2317struct opa_pma_mad {
2318 struct ib_mad_hdr mad_hdr;
2319 u8 data[2024];
2320} __packed;
2321
2322struct opa_port_status_req {
2323 __u8 port_num;
2324 __u8 reserved[3];
2325 __be32 vl_select_mask;
2326};
2327
2328#define VL_MASK_ALL 0x00000000000080ffUL
2329
2330struct opa_port_status_rsp {
2331 __u8 port_num;
2332 __u8 reserved[3];
2333 __be32 vl_select_mask;
2334
2335
2336 __be64 port_xmit_data;
2337 __be64 port_rcv_data;
2338 __be64 port_xmit_pkts;
2339 __be64 port_rcv_pkts;
2340 __be64 port_multicast_xmit_pkts;
2341 __be64 port_multicast_rcv_pkts;
2342 __be64 port_xmit_wait;
2343 __be64 sw_port_congestion;
2344 __be64 port_rcv_fecn;
2345 __be64 port_rcv_becn;
2346 __be64 port_xmit_time_cong;
2347 __be64 port_xmit_wasted_bw;
2348 __be64 port_xmit_wait_data;
2349 __be64 port_rcv_bubble;
2350 __be64 port_mark_fecn;
2351
2352 __be64 port_rcv_constraint_errors;
2353 __be64 port_rcv_switch_relay_errors;
2354 __be64 port_xmit_discards;
2355 __be64 port_xmit_constraint_errors;
2356 __be64 port_rcv_remote_physical_errors;
2357 __be64 local_link_integrity_errors;
2358 __be64 port_rcv_errors;
2359 __be64 excessive_buffer_overruns;
2360 __be64 fm_config_errors;
2361 __be32 link_error_recovery;
2362 __be32 link_downed;
2363 u8 uncorrectable_errors;
2364
2365 u8 link_quality_indicator;
2366 u8 res2[6];
2367 struct _vls_pctrs {
2368
2369 __be64 port_vl_xmit_data;
2370 __be64 port_vl_rcv_data;
2371 __be64 port_vl_xmit_pkts;
2372 __be64 port_vl_rcv_pkts;
2373 __be64 port_vl_xmit_wait;
2374 __be64 sw_port_vl_congestion;
2375 __be64 port_vl_rcv_fecn;
2376 __be64 port_vl_rcv_becn;
2377 __be64 port_xmit_time_cong;
2378 __be64 port_vl_xmit_wasted_bw;
2379 __be64 port_vl_xmit_wait_data;
2380 __be64 port_vl_rcv_bubble;
2381 __be64 port_vl_mark_fecn;
2382 __be64 port_vl_xmit_discards;
2383 } vls[];
2384};
2385
2386enum counter_selects {
2387 CS_PORT_XMIT_DATA = (1 << 31),
2388 CS_PORT_RCV_DATA = (1 << 30),
2389 CS_PORT_XMIT_PKTS = (1 << 29),
2390 CS_PORT_RCV_PKTS = (1 << 28),
2391 CS_PORT_MCAST_XMIT_PKTS = (1 << 27),
2392 CS_PORT_MCAST_RCV_PKTS = (1 << 26),
2393 CS_PORT_XMIT_WAIT = (1 << 25),
2394 CS_SW_PORT_CONGESTION = (1 << 24),
2395 CS_PORT_RCV_FECN = (1 << 23),
2396 CS_PORT_RCV_BECN = (1 << 22),
2397 CS_PORT_XMIT_TIME_CONG = (1 << 21),
2398 CS_PORT_XMIT_WASTED_BW = (1 << 20),
2399 CS_PORT_XMIT_WAIT_DATA = (1 << 19),
2400 CS_PORT_RCV_BUBBLE = (1 << 18),
2401 CS_PORT_MARK_FECN = (1 << 17),
2402 CS_PORT_RCV_CONSTRAINT_ERRORS = (1 << 16),
2403 CS_PORT_RCV_SWITCH_RELAY_ERRORS = (1 << 15),
2404 CS_PORT_XMIT_DISCARDS = (1 << 14),
2405 CS_PORT_XMIT_CONSTRAINT_ERRORS = (1 << 13),
2406 CS_PORT_RCV_REMOTE_PHYSICAL_ERRORS = (1 << 12),
2407 CS_LOCAL_LINK_INTEGRITY_ERRORS = (1 << 11),
2408 CS_PORT_RCV_ERRORS = (1 << 10),
2409 CS_EXCESSIVE_BUFFER_OVERRUNS = (1 << 9),
2410 CS_FM_CONFIG_ERRORS = (1 << 8),
2411 CS_LINK_ERROR_RECOVERY = (1 << 7),
2412 CS_LINK_DOWNED = (1 << 6),
2413 CS_UNCORRECTABLE_ERRORS = (1 << 5),
2414};
2415
2416struct opa_clear_port_status {
2417 __be64 port_select_mask[4];
2418 __be32 counter_select_mask;
2419};
2420
2421struct opa_aggregate {
2422 __be16 attr_id;
2423 __be16 err_reqlength;
2424 __be32 attr_mod;
2425 u8 data[];
2426};
2427
2428#define MSK_LLI 0x000000f0
2429#define MSK_LLI_SFT 4
2430#define MSK_LER 0x0000000f
2431#define MSK_LER_SFT 0
2432#define ADD_LLI 8
2433#define ADD_LER 2
2434
2435
2436struct opa_port_data_counters_msg {
2437 __be64 port_select_mask[4];
2438 __be32 vl_select_mask;
2439 __be32 resolution;
2440
2441
2442 struct _port_dctrs {
2443 u8 port_number;
2444 u8 reserved2[3];
2445 __be32 link_quality_indicator;
2446
2447
2448 __be64 port_xmit_data;
2449 __be64 port_rcv_data;
2450 __be64 port_xmit_pkts;
2451 __be64 port_rcv_pkts;
2452 __be64 port_multicast_xmit_pkts;
2453 __be64 port_multicast_rcv_pkts;
2454 __be64 port_xmit_wait;
2455 __be64 sw_port_congestion;
2456 __be64 port_rcv_fecn;
2457 __be64 port_rcv_becn;
2458 __be64 port_xmit_time_cong;
2459 __be64 port_xmit_wasted_bw;
2460 __be64 port_xmit_wait_data;
2461 __be64 port_rcv_bubble;
2462 __be64 port_mark_fecn;
2463
2464 __be64 port_error_counter_summary;
2465
2466
2467 struct _vls_dctrs {
2468
2469 __be64 port_vl_xmit_data;
2470 __be64 port_vl_rcv_data;
2471 __be64 port_vl_xmit_pkts;
2472 __be64 port_vl_rcv_pkts;
2473 __be64 port_vl_xmit_wait;
2474 __be64 sw_port_vl_congestion;
2475 __be64 port_vl_rcv_fecn;
2476 __be64 port_vl_rcv_becn;
2477 __be64 port_xmit_time_cong;
2478 __be64 port_vl_xmit_wasted_bw;
2479 __be64 port_vl_xmit_wait_data;
2480 __be64 port_vl_rcv_bubble;
2481 __be64 port_vl_mark_fecn;
2482 } vls[0];
2483
2484 } port[1];
2485};
2486
2487struct opa_port_error_counters64_msg {
2488
2489
2490
2491
2492 __be64 port_select_mask[4];
2493 __be32 vl_select_mask;
2494
2495
2496 __be32 reserved1;
2497 struct _port_ectrs {
2498 u8 port_number;
2499 u8 reserved2[7];
2500 __be64 port_rcv_constraint_errors;
2501 __be64 port_rcv_switch_relay_errors;
2502 __be64 port_xmit_discards;
2503 __be64 port_xmit_constraint_errors;
2504 __be64 port_rcv_remote_physical_errors;
2505 __be64 local_link_integrity_errors;
2506 __be64 port_rcv_errors;
2507 __be64 excessive_buffer_overruns;
2508 __be64 fm_config_errors;
2509 __be32 link_error_recovery;
2510 __be32 link_downed;
2511 u8 uncorrectable_errors;
2512 u8 reserved3[7];
2513 struct _vls_ectrs {
2514 __be64 port_vl_xmit_discards;
2515 } vls[0];
2516
2517 } port[1];
2518};
2519
2520struct opa_port_error_info_msg {
2521 __be64 port_select_mask[4];
2522 __be32 error_info_select_mask;
2523 __be32 reserved1;
2524 struct _port_ei {
2525 u8 port_number;
2526 u8 reserved2[7];
2527
2528
2529 struct {
2530 u8 status_and_code;
2531 union {
2532 u8 raw[17];
2533 struct {
2534
2535 u8 packet_flit1[8];
2536 u8 packet_flit2[8];
2537 u8 remaining_flit_bits12;
2538 } ei1to12;
2539 struct {
2540 u8 packet_bytes[8];
2541 u8 remaining_flit_bits;
2542 } ei13;
2543 } ei;
2544 u8 reserved3[6];
2545 } __packed port_rcv_ei;
2546
2547
2548 struct {
2549 u8 status_and_sc;
2550 u8 reserved4[7];
2551 } __packed excessive_buffer_overrun_ei;
2552
2553
2554 struct {
2555 u8 status;
2556 u8 reserved5;
2557 __be16 pkey;
2558 __be32 slid;
2559 } __packed port_xmit_constraint_ei;
2560
2561
2562 struct {
2563 u8 status;
2564 u8 reserved6;
2565 __be16 pkey;
2566 __be32 slid;
2567 } __packed port_rcv_constraint_ei;
2568
2569
2570 struct {
2571 u8 status_and_code;
2572 u8 reserved7[3];
2573 __u32 error_info;
2574 } __packed port_rcv_switch_relay_ei;
2575
2576
2577 struct {
2578 u8 status_and_code;
2579 u8 reserved8;
2580 } __packed uncorrectable_ei;
2581
2582
2583 struct {
2584 u8 status_and_code;
2585 u8 error_info;
2586 } __packed fm_config_ei;
2587 __u32 reserved9;
2588 } port[1];
2589};
2590
2591
2592enum error_info_selects {
2593 ES_PORT_RCV_ERROR_INFO = (1 << 31),
2594 ES_EXCESSIVE_BUFFER_OVERRUN_INFO = (1 << 30),
2595 ES_PORT_XMIT_CONSTRAINT_ERROR_INFO = (1 << 29),
2596 ES_PORT_RCV_CONSTRAINT_ERROR_INFO = (1 << 28),
2597 ES_PORT_RCV_SWITCH_RELAY_ERROR_INFO = (1 << 27),
2598 ES_UNCORRECTABLE_ERROR_INFO = (1 << 26),
2599 ES_FM_CONFIG_ERROR_INFO = (1 << 25)
2600};
2601
2602static int pma_get_opa_classportinfo(struct opa_pma_mad *pmp,
2603 struct ib_device *ibdev, u32 *resp_len)
2604{
2605 struct opa_class_port_info *p =
2606 (struct opa_class_port_info *)pmp->data;
2607
2608 memset(pmp->data, 0, sizeof(pmp->data));
2609
2610 if (pmp->mad_hdr.attr_mod != 0)
2611 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
2612
2613 p->base_version = OPA_MGMT_BASE_VERSION;
2614 p->class_version = OPA_SM_CLASS_VERSION;
2615
2616
2617
2618 p->cap_mask2_resp_time = cpu_to_be32(18);
2619
2620 if (resp_len)
2621 *resp_len += sizeof(*p);
2622
2623 return reply((struct ib_mad_hdr *)pmp);
2624}
2625
2626static void a0_portstatus(struct hfi1_pportdata *ppd,
2627 struct opa_port_status_rsp *rsp)
2628{
2629 if (!is_bx(ppd->dd)) {
2630 unsigned long vl;
2631 u64 sum_vl_xmit_wait = 0;
2632 unsigned long vl_all_mask = VL_MASK_ALL;
2633
2634 for_each_set_bit(vl, &vl_all_mask, BITS_PER_LONG) {
2635 u64 tmp = sum_vl_xmit_wait +
2636 read_port_cntr(ppd, C_TX_WAIT_VL,
2637 idx_from_vl(vl));
2638 if (tmp < sum_vl_xmit_wait) {
2639
2640 sum_vl_xmit_wait = (u64)~0;
2641 break;
2642 }
2643 sum_vl_xmit_wait = tmp;
2644 }
2645 if (be64_to_cpu(rsp->port_xmit_wait) > sum_vl_xmit_wait)
2646 rsp->port_xmit_wait = cpu_to_be64(sum_vl_xmit_wait);
2647 }
2648}
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659u16 tx_link_width(u16 link_width)
2660{
2661 int n = LINK_WIDTH_DEFAULT;
2662 u16 tx_width = n;
2663
2664 while (link_width && n) {
2665 if (link_width & (1 << (n - 1))) {
2666 tx_width = n;
2667 break;
2668 }
2669 n--;
2670 }
2671
2672 return tx_width;
2673}
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692u64 get_xmit_wait_counters(struct hfi1_pportdata *ppd,
2693 u16 link_width, u16 link_speed, int vl)
2694{
2695 u64 port_vl_xmit_wait_curr;
2696 u64 delta_vl_xmit_wait;
2697 u64 xmit_wait_val;
2698
2699 if (vl > C_VL_COUNT)
2700 return 0;
2701 if (vl < C_VL_COUNT)
2702 port_vl_xmit_wait_curr =
2703 read_port_cntr(ppd, C_TX_WAIT_VL, vl);
2704 else
2705 port_vl_xmit_wait_curr =
2706 read_port_cntr(ppd, C_TX_WAIT, CNTR_INVALID_VL);
2707
2708 xmit_wait_val =
2709 port_vl_xmit_wait_curr -
2710 ppd->port_vl_xmit_wait_last[vl];
2711 delta_vl_xmit_wait =
2712 convert_xmit_counter(xmit_wait_val,
2713 ppd->prev_link_width,
2714 link_speed);
2715
2716 ppd->vl_xmit_flit_cnt[vl] += delta_vl_xmit_wait;
2717 ppd->port_vl_xmit_wait_last[vl] = port_vl_xmit_wait_curr;
2718 ppd->prev_link_width = link_width;
2719
2720 return ppd->vl_xmit_flit_cnt[vl];
2721}
2722
2723static int pma_get_opa_portstatus(struct opa_pma_mad *pmp,
2724 struct ib_device *ibdev,
2725 u32 port, u32 *resp_len)
2726{
2727 struct opa_port_status_req *req =
2728 (struct opa_port_status_req *)pmp->data;
2729 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2730 struct opa_port_status_rsp *rsp;
2731 unsigned long vl_select_mask = be32_to_cpu(req->vl_select_mask);
2732 unsigned long vl;
2733 size_t response_data_size;
2734 u32 nports = be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24;
2735 u32 port_num = req->port_num;
2736 u8 num_vls = hweight64(vl_select_mask);
2737 struct _vls_pctrs *vlinfo;
2738 struct hfi1_ibport *ibp = to_iport(ibdev, port);
2739 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
2740 int vfi;
2741 u64 tmp, tmp2;
2742 u16 link_width;
2743 u16 link_speed;
2744
2745 response_data_size = struct_size(rsp, vls, num_vls);
2746 if (response_data_size > sizeof(pmp->data)) {
2747 pmp->mad_hdr.status |= OPA_PM_STATUS_REQUEST_TOO_LARGE;
2748 return reply((struct ib_mad_hdr *)pmp);
2749 }
2750
2751 if (nports != 1 || (port_num && port_num != port) ||
2752 num_vls > OPA_MAX_VLS || (vl_select_mask & ~VL_MASK_ALL)) {
2753 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
2754 return reply((struct ib_mad_hdr *)pmp);
2755 }
2756
2757 memset(pmp->data, 0, sizeof(pmp->data));
2758
2759 rsp = (struct opa_port_status_rsp *)pmp->data;
2760 if (port_num)
2761 rsp->port_num = port_num;
2762 else
2763 rsp->port_num = port;
2764
2765 rsp->port_rcv_constraint_errors =
2766 cpu_to_be64(read_port_cntr(ppd, C_SW_RCV_CSTR_ERR,
2767 CNTR_INVALID_VL));
2768
2769 hfi1_read_link_quality(dd, &rsp->link_quality_indicator);
2770
2771 rsp->vl_select_mask = cpu_to_be32((u32)vl_select_mask);
2772 rsp->port_xmit_data = cpu_to_be64(read_dev_cntr(dd, C_DC_XMIT_FLITS,
2773 CNTR_INVALID_VL));
2774 rsp->port_rcv_data = cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FLITS,
2775 CNTR_INVALID_VL));
2776 rsp->port_xmit_pkts = cpu_to_be64(read_dev_cntr(dd, C_DC_XMIT_PKTS,
2777 CNTR_INVALID_VL));
2778 rsp->port_rcv_pkts = cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_PKTS,
2779 CNTR_INVALID_VL));
2780 rsp->port_multicast_xmit_pkts =
2781 cpu_to_be64(read_dev_cntr(dd, C_DC_MC_XMIT_PKTS,
2782 CNTR_INVALID_VL));
2783 rsp->port_multicast_rcv_pkts =
2784 cpu_to_be64(read_dev_cntr(dd, C_DC_MC_RCV_PKTS,
2785 CNTR_INVALID_VL));
2786
2787
2788
2789
2790 link_width =
2791 tx_link_width(ppd->link_width_downgrade_tx_active);
2792 link_speed = get_link_speed(ppd->link_speed_active);
2793 rsp->port_xmit_wait =
2794 cpu_to_be64(get_xmit_wait_counters(ppd, link_width,
2795 link_speed, C_VL_COUNT));
2796 rsp->port_rcv_fecn =
2797 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FCN, CNTR_INVALID_VL));
2798 rsp->port_rcv_becn =
2799 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_BCN, CNTR_INVALID_VL));
2800 rsp->port_xmit_discards =
2801 cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_DSCD,
2802 CNTR_INVALID_VL));
2803 rsp->port_xmit_constraint_errors =
2804 cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_CSTR_ERR,
2805 CNTR_INVALID_VL));
2806 rsp->port_rcv_remote_physical_errors =
2807 cpu_to_be64(read_dev_cntr(dd, C_DC_RMT_PHY_ERR,
2808 CNTR_INVALID_VL));
2809 rsp->local_link_integrity_errors =
2810 cpu_to_be64(read_dev_cntr(dd, C_DC_RX_REPLAY,
2811 CNTR_INVALID_VL));
2812 tmp = read_dev_cntr(dd, C_DC_SEQ_CRC_CNT, CNTR_INVALID_VL);
2813 tmp2 = tmp + read_dev_cntr(dd, C_DC_REINIT_FROM_PEER_CNT,
2814 CNTR_INVALID_VL);
2815 if (tmp2 > (u32)UINT_MAX || tmp2 < tmp) {
2816
2817 rsp->link_error_recovery = cpu_to_be32(~0);
2818 } else {
2819 rsp->link_error_recovery = cpu_to_be32(tmp2);
2820 }
2821 rsp->port_rcv_errors =
2822 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_ERR, CNTR_INVALID_VL));
2823 rsp->excessive_buffer_overruns =
2824 cpu_to_be64(read_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL));
2825 rsp->fm_config_errors =
2826 cpu_to_be64(read_dev_cntr(dd, C_DC_FM_CFG_ERR,
2827 CNTR_INVALID_VL));
2828 rsp->link_downed = cpu_to_be32(read_port_cntr(ppd, C_SW_LINK_DOWN,
2829 CNTR_INVALID_VL));
2830
2831
2832 tmp = read_dev_cntr(dd, C_DC_UNC_ERR, CNTR_INVALID_VL);
2833 rsp->uncorrectable_errors = tmp < 0x100 ? (tmp & 0xff) : 0xff;
2834
2835 vlinfo = &rsp->vls[0];
2836 vfi = 0;
2837
2838
2839
2840
2841
2842 for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
2843 memset(vlinfo, 0, sizeof(*vlinfo));
2844
2845 tmp = read_dev_cntr(dd, C_DC_RX_FLIT_VL, idx_from_vl(vl));
2846 rsp->vls[vfi].port_vl_rcv_data = cpu_to_be64(tmp);
2847
2848 rsp->vls[vfi].port_vl_rcv_pkts =
2849 cpu_to_be64(read_dev_cntr(dd, C_DC_RX_PKT_VL,
2850 idx_from_vl(vl)));
2851
2852 rsp->vls[vfi].port_vl_xmit_data =
2853 cpu_to_be64(read_port_cntr(ppd, C_TX_FLIT_VL,
2854 idx_from_vl(vl)));
2855
2856 rsp->vls[vfi].port_vl_xmit_pkts =
2857 cpu_to_be64(read_port_cntr(ppd, C_TX_PKT_VL,
2858 idx_from_vl(vl)));
2859
2860
2861
2862
2863 rsp->vls[vfi].port_vl_xmit_wait =
2864 cpu_to_be64(get_xmit_wait_counters(ppd, link_width,
2865 link_speed,
2866 idx_from_vl(vl)));
2867
2868 rsp->vls[vfi].port_vl_rcv_fecn =
2869 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FCN_VL,
2870 idx_from_vl(vl)));
2871
2872 rsp->vls[vfi].port_vl_rcv_becn =
2873 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_BCN_VL,
2874 idx_from_vl(vl)));
2875
2876 rsp->vls[vfi].port_vl_xmit_discards =
2877 cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_DSCD_VL,
2878 idx_from_vl(vl)));
2879 vlinfo++;
2880 vfi++;
2881 }
2882
2883 a0_portstatus(ppd, rsp);
2884
2885 if (resp_len)
2886 *resp_len += response_data_size;
2887
2888 return reply((struct ib_mad_hdr *)pmp);
2889}
2890
2891static u64 get_error_counter_summary(struct ib_device *ibdev, u32 port,
2892 u8 res_lli, u8 res_ler)
2893{
2894 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2895 struct hfi1_ibport *ibp = to_iport(ibdev, port);
2896 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
2897 u64 error_counter_summary = 0, tmp;
2898
2899 error_counter_summary += read_port_cntr(ppd, C_SW_RCV_CSTR_ERR,
2900 CNTR_INVALID_VL);
2901
2902 error_counter_summary += read_port_cntr(ppd, C_SW_XMIT_DSCD,
2903 CNTR_INVALID_VL);
2904 error_counter_summary += read_port_cntr(ppd, C_SW_XMIT_CSTR_ERR,
2905 CNTR_INVALID_VL);
2906 error_counter_summary += read_dev_cntr(dd, C_DC_RMT_PHY_ERR,
2907 CNTR_INVALID_VL);
2908
2909 error_counter_summary += (read_dev_cntr(dd, C_DC_RX_REPLAY,
2910 CNTR_INVALID_VL) >> res_lli);
2911
2912 tmp = read_dev_cntr(dd, C_DC_SEQ_CRC_CNT, CNTR_INVALID_VL);
2913 tmp += read_dev_cntr(dd, C_DC_REINIT_FROM_PEER_CNT, CNTR_INVALID_VL);
2914 error_counter_summary += (tmp >> res_ler);
2915 error_counter_summary += read_dev_cntr(dd, C_DC_RCV_ERR,
2916 CNTR_INVALID_VL);
2917 error_counter_summary += read_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL);
2918 error_counter_summary += read_dev_cntr(dd, C_DC_FM_CFG_ERR,
2919 CNTR_INVALID_VL);
2920
2921 error_counter_summary += read_port_cntr(ppd, C_SW_LINK_DOWN,
2922 CNTR_INVALID_VL);
2923 tmp = read_dev_cntr(dd, C_DC_UNC_ERR, CNTR_INVALID_VL);
2924
2925 error_counter_summary += tmp < 0x100 ? (tmp & 0xff) : 0xff;
2926
2927 return error_counter_summary;
2928}
2929
2930static void a0_datacounters(struct hfi1_pportdata *ppd, struct _port_dctrs *rsp)
2931{
2932 if (!is_bx(ppd->dd)) {
2933 unsigned long vl;
2934 u64 sum_vl_xmit_wait = 0;
2935 unsigned long vl_all_mask = VL_MASK_ALL;
2936
2937 for_each_set_bit(vl, &vl_all_mask, BITS_PER_LONG) {
2938 u64 tmp = sum_vl_xmit_wait +
2939 read_port_cntr(ppd, C_TX_WAIT_VL,
2940 idx_from_vl(vl));
2941 if (tmp < sum_vl_xmit_wait) {
2942
2943 sum_vl_xmit_wait = (u64)~0;
2944 break;
2945 }
2946 sum_vl_xmit_wait = tmp;
2947 }
2948 if (be64_to_cpu(rsp->port_xmit_wait) > sum_vl_xmit_wait)
2949 rsp->port_xmit_wait = cpu_to_be64(sum_vl_xmit_wait);
2950 }
2951}
2952
2953static void pma_get_opa_port_dctrs(struct ib_device *ibdev,
2954 struct _port_dctrs *rsp)
2955{
2956 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2957
2958 rsp->port_xmit_data = cpu_to_be64(read_dev_cntr(dd, C_DC_XMIT_FLITS,
2959 CNTR_INVALID_VL));
2960 rsp->port_rcv_data = cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FLITS,
2961 CNTR_INVALID_VL));
2962 rsp->port_xmit_pkts = cpu_to_be64(read_dev_cntr(dd, C_DC_XMIT_PKTS,
2963 CNTR_INVALID_VL));
2964 rsp->port_rcv_pkts = cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_PKTS,
2965 CNTR_INVALID_VL));
2966 rsp->port_multicast_xmit_pkts =
2967 cpu_to_be64(read_dev_cntr(dd, C_DC_MC_XMIT_PKTS,
2968 CNTR_INVALID_VL));
2969 rsp->port_multicast_rcv_pkts =
2970 cpu_to_be64(read_dev_cntr(dd, C_DC_MC_RCV_PKTS,
2971 CNTR_INVALID_VL));
2972}
2973
2974static int pma_get_opa_datacounters(struct opa_pma_mad *pmp,
2975 struct ib_device *ibdev,
2976 u32 port, u32 *resp_len)
2977{
2978 struct opa_port_data_counters_msg *req =
2979 (struct opa_port_data_counters_msg *)pmp->data;
2980 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
2981 struct hfi1_ibport *ibp = to_iport(ibdev, port);
2982 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
2983 struct _port_dctrs *rsp;
2984 struct _vls_dctrs *vlinfo;
2985 size_t response_data_size;
2986 u32 num_ports;
2987 u8 lq, num_vls;
2988 u8 res_lli, res_ler;
2989 u64 port_mask;
2990 u32 port_num;
2991 unsigned long vl;
2992 unsigned long vl_select_mask;
2993 int vfi;
2994 u16 link_width;
2995 u16 link_speed;
2996
2997 num_ports = be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24;
2998 num_vls = hweight32(be32_to_cpu(req->vl_select_mask));
2999 vl_select_mask = be32_to_cpu(req->vl_select_mask);
3000 res_lli = (u8)(be32_to_cpu(req->resolution) & MSK_LLI) >> MSK_LLI_SFT;
3001 res_lli = res_lli ? res_lli + ADD_LLI : 0;
3002 res_ler = (u8)(be32_to_cpu(req->resolution) & MSK_LER) >> MSK_LER_SFT;
3003 res_ler = res_ler ? res_ler + ADD_LER : 0;
3004
3005 if (num_ports != 1 || (vl_select_mask & ~VL_MASK_ALL)) {
3006 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3007 return reply((struct ib_mad_hdr *)pmp);
3008 }
3009
3010
3011 response_data_size = struct_size(req, port[0].vls, num_vls);
3012
3013 if (response_data_size > sizeof(pmp->data)) {
3014 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3015 return reply((struct ib_mad_hdr *)pmp);
3016 }
3017
3018
3019
3020
3021
3022 port_mask = be64_to_cpu(req->port_select_mask[3]);
3023 port_num = find_first_bit((unsigned long *)&port_mask,
3024 sizeof(port_mask) * 8);
3025
3026 if (port_num != port) {
3027 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3028 return reply((struct ib_mad_hdr *)pmp);
3029 }
3030
3031 rsp = &req->port[0];
3032 memset(rsp, 0, sizeof(*rsp));
3033
3034 rsp->port_number = port;
3035
3036
3037
3038
3039
3040 hfi1_read_link_quality(dd, &lq);
3041 rsp->link_quality_indicator = cpu_to_be32((u32)lq);
3042 pma_get_opa_port_dctrs(ibdev, rsp);
3043
3044
3045
3046
3047
3048 link_width =
3049 tx_link_width(ppd->link_width_downgrade_tx_active);
3050 link_speed = get_link_speed(ppd->link_speed_active);
3051 rsp->port_xmit_wait =
3052 cpu_to_be64(get_xmit_wait_counters(ppd, link_width,
3053 link_speed, C_VL_COUNT));
3054 rsp->port_rcv_fecn =
3055 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FCN, CNTR_INVALID_VL));
3056 rsp->port_rcv_becn =
3057 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_BCN, CNTR_INVALID_VL));
3058 rsp->port_error_counter_summary =
3059 cpu_to_be64(get_error_counter_summary(ibdev, port,
3060 res_lli, res_ler));
3061
3062 vlinfo = &rsp->vls[0];
3063 vfi = 0;
3064
3065
3066
3067
3068
3069 for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
3070 memset(vlinfo, 0, sizeof(*vlinfo));
3071
3072 rsp->vls[vfi].port_vl_xmit_data =
3073 cpu_to_be64(read_port_cntr(ppd, C_TX_FLIT_VL,
3074 idx_from_vl(vl)));
3075
3076 rsp->vls[vfi].port_vl_rcv_data =
3077 cpu_to_be64(read_dev_cntr(dd, C_DC_RX_FLIT_VL,
3078 idx_from_vl(vl)));
3079
3080 rsp->vls[vfi].port_vl_xmit_pkts =
3081 cpu_to_be64(read_port_cntr(ppd, C_TX_PKT_VL,
3082 idx_from_vl(vl)));
3083
3084 rsp->vls[vfi].port_vl_rcv_pkts =
3085 cpu_to_be64(read_dev_cntr(dd, C_DC_RX_PKT_VL,
3086 idx_from_vl(vl)));
3087
3088
3089
3090
3091
3092 rsp->vls[vfi].port_vl_xmit_wait =
3093 cpu_to_be64(get_xmit_wait_counters(ppd, link_width,
3094 link_speed,
3095 idx_from_vl(vl)));
3096
3097 rsp->vls[vfi].port_vl_rcv_fecn =
3098 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FCN_VL,
3099 idx_from_vl(vl)));
3100 rsp->vls[vfi].port_vl_rcv_becn =
3101 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_BCN_VL,
3102 idx_from_vl(vl)));
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113 vlinfo++;
3114 vfi++;
3115 }
3116
3117 a0_datacounters(ppd, rsp);
3118
3119 if (resp_len)
3120 *resp_len += response_data_size;
3121
3122 return reply((struct ib_mad_hdr *)pmp);
3123}
3124
3125static int pma_get_ib_portcounters_ext(struct ib_pma_mad *pmp,
3126 struct ib_device *ibdev, u32 port)
3127{
3128 struct ib_pma_portcounters_ext *p = (struct ib_pma_portcounters_ext *)
3129 pmp->data;
3130 struct _port_dctrs rsp;
3131
3132 if (pmp->mad_hdr.attr_mod != 0 || p->port_select != port) {
3133 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3134 goto bail;
3135 }
3136
3137 memset(&rsp, 0, sizeof(rsp));
3138 pma_get_opa_port_dctrs(ibdev, &rsp);
3139
3140 p->port_xmit_data = rsp.port_xmit_data;
3141 p->port_rcv_data = rsp.port_rcv_data;
3142 p->port_xmit_packets = rsp.port_xmit_pkts;
3143 p->port_rcv_packets = rsp.port_rcv_pkts;
3144 p->port_unicast_xmit_packets = 0;
3145 p->port_unicast_rcv_packets = 0;
3146 p->port_multicast_xmit_packets = rsp.port_multicast_xmit_pkts;
3147 p->port_multicast_rcv_packets = rsp.port_multicast_rcv_pkts;
3148
3149bail:
3150 return reply((struct ib_mad_hdr *)pmp);
3151}
3152
3153static void pma_get_opa_port_ectrs(struct ib_device *ibdev,
3154 struct _port_ectrs *rsp, u32 port)
3155{
3156 u64 tmp, tmp2;
3157 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
3158 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3159 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3160
3161 tmp = read_dev_cntr(dd, C_DC_SEQ_CRC_CNT, CNTR_INVALID_VL);
3162 tmp2 = tmp + read_dev_cntr(dd, C_DC_REINIT_FROM_PEER_CNT,
3163 CNTR_INVALID_VL);
3164 if (tmp2 > (u32)UINT_MAX || tmp2 < tmp) {
3165
3166 rsp->link_error_recovery = cpu_to_be32(~0);
3167 } else {
3168 rsp->link_error_recovery = cpu_to_be32(tmp2);
3169 }
3170
3171 rsp->link_downed = cpu_to_be32(read_port_cntr(ppd, C_SW_LINK_DOWN,
3172 CNTR_INVALID_VL));
3173 rsp->port_rcv_errors =
3174 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_ERR, CNTR_INVALID_VL));
3175 rsp->port_rcv_remote_physical_errors =
3176 cpu_to_be64(read_dev_cntr(dd, C_DC_RMT_PHY_ERR,
3177 CNTR_INVALID_VL));
3178 rsp->port_rcv_switch_relay_errors = 0;
3179 rsp->port_xmit_discards =
3180 cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_DSCD,
3181 CNTR_INVALID_VL));
3182 rsp->port_xmit_constraint_errors =
3183 cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_CSTR_ERR,
3184 CNTR_INVALID_VL));
3185 rsp->port_rcv_constraint_errors =
3186 cpu_to_be64(read_port_cntr(ppd, C_SW_RCV_CSTR_ERR,
3187 CNTR_INVALID_VL));
3188 rsp->local_link_integrity_errors =
3189 cpu_to_be64(read_dev_cntr(dd, C_DC_RX_REPLAY,
3190 CNTR_INVALID_VL));
3191 rsp->excessive_buffer_overruns =
3192 cpu_to_be64(read_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL));
3193}
3194
3195static int pma_get_opa_porterrors(struct opa_pma_mad *pmp,
3196 struct ib_device *ibdev,
3197 u32 port, u32 *resp_len)
3198{
3199 size_t response_data_size;
3200 struct _port_ectrs *rsp;
3201 u32 port_num;
3202 struct opa_port_error_counters64_msg *req;
3203 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
3204 u32 num_ports;
3205 u8 num_pslm;
3206 u8 num_vls;
3207 struct hfi1_ibport *ibp;
3208 struct hfi1_pportdata *ppd;
3209 struct _vls_ectrs *vlinfo;
3210 unsigned long vl;
3211 u64 port_mask, tmp;
3212 unsigned long vl_select_mask;
3213 int vfi;
3214
3215 req = (struct opa_port_error_counters64_msg *)pmp->data;
3216
3217 num_ports = be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24;
3218
3219 num_pslm = hweight64(be64_to_cpu(req->port_select_mask[3]));
3220 num_vls = hweight32(be32_to_cpu(req->vl_select_mask));
3221
3222 if (num_ports != 1 || num_ports != num_pslm) {
3223 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3224 return reply((struct ib_mad_hdr *)pmp);
3225 }
3226
3227 response_data_size = struct_size(req, port[0].vls, num_vls);
3228
3229 if (response_data_size > sizeof(pmp->data)) {
3230 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3231 return reply((struct ib_mad_hdr *)pmp);
3232 }
3233
3234
3235
3236
3237 port_mask = be64_to_cpu(req->port_select_mask[3]);
3238 port_num = find_first_bit((unsigned long *)&port_mask,
3239 sizeof(port_mask) * 8);
3240
3241 if (port_num != port) {
3242 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3243 return reply((struct ib_mad_hdr *)pmp);
3244 }
3245
3246 rsp = &req->port[0];
3247
3248 ibp = to_iport(ibdev, port_num);
3249 ppd = ppd_from_ibp(ibp);
3250
3251 memset(rsp, 0, sizeof(*rsp));
3252 rsp->port_number = port_num;
3253
3254 pma_get_opa_port_ectrs(ibdev, rsp, port_num);
3255
3256 rsp->port_rcv_remote_physical_errors =
3257 cpu_to_be64(read_dev_cntr(dd, C_DC_RMT_PHY_ERR,
3258 CNTR_INVALID_VL));
3259 rsp->fm_config_errors =
3260 cpu_to_be64(read_dev_cntr(dd, C_DC_FM_CFG_ERR,
3261 CNTR_INVALID_VL));
3262 tmp = read_dev_cntr(dd, C_DC_UNC_ERR, CNTR_INVALID_VL);
3263
3264 rsp->uncorrectable_errors = tmp < 0x100 ? (tmp & 0xff) : 0xff;
3265 rsp->port_rcv_errors =
3266 cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_ERR, CNTR_INVALID_VL));
3267 vlinfo = &rsp->vls[0];
3268 vfi = 0;
3269 vl_select_mask = be32_to_cpu(req->vl_select_mask);
3270 for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
3271 memset(vlinfo, 0, sizeof(*vlinfo));
3272 rsp->vls[vfi].port_vl_xmit_discards =
3273 cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_DSCD_VL,
3274 idx_from_vl(vl)));
3275 vlinfo += 1;
3276 vfi++;
3277 }
3278
3279 if (resp_len)
3280 *resp_len += response_data_size;
3281
3282 return reply((struct ib_mad_hdr *)pmp);
3283}
3284
3285static int pma_get_ib_portcounters(struct ib_pma_mad *pmp,
3286 struct ib_device *ibdev, u32 port)
3287{
3288 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
3289 pmp->data;
3290 struct _port_ectrs rsp;
3291 u64 temp_link_overrun_errors;
3292 u64 temp_64;
3293 u32 temp_32;
3294
3295 memset(&rsp, 0, sizeof(rsp));
3296 pma_get_opa_port_ectrs(ibdev, &rsp, port);
3297
3298 if (pmp->mad_hdr.attr_mod != 0 || p->port_select != port) {
3299 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3300 goto bail;
3301 }
3302
3303 p->symbol_error_counter = 0;
3304
3305 temp_32 = be32_to_cpu(rsp.link_error_recovery);
3306 if (temp_32 > 0xFFUL)
3307 p->link_error_recovery_counter = 0xFF;
3308 else
3309 p->link_error_recovery_counter = (u8)temp_32;
3310
3311 temp_32 = be32_to_cpu(rsp.link_downed);
3312 if (temp_32 > 0xFFUL)
3313 p->link_downed_counter = 0xFF;
3314 else
3315 p->link_downed_counter = (u8)temp_32;
3316
3317 temp_64 = be64_to_cpu(rsp.port_rcv_errors);
3318 if (temp_64 > 0xFFFFUL)
3319 p->port_rcv_errors = cpu_to_be16(0xFFFF);
3320 else
3321 p->port_rcv_errors = cpu_to_be16((u16)temp_64);
3322
3323 temp_64 = be64_to_cpu(rsp.port_rcv_remote_physical_errors);
3324 if (temp_64 > 0xFFFFUL)
3325 p->port_rcv_remphys_errors = cpu_to_be16(0xFFFF);
3326 else
3327 p->port_rcv_remphys_errors = cpu_to_be16((u16)temp_64);
3328
3329 temp_64 = be64_to_cpu(rsp.port_rcv_switch_relay_errors);
3330 p->port_rcv_switch_relay_errors = cpu_to_be16((u16)temp_64);
3331
3332 temp_64 = be64_to_cpu(rsp.port_xmit_discards);
3333 if (temp_64 > 0xFFFFUL)
3334 p->port_xmit_discards = cpu_to_be16(0xFFFF);
3335 else
3336 p->port_xmit_discards = cpu_to_be16((u16)temp_64);
3337
3338 temp_64 = be64_to_cpu(rsp.port_xmit_constraint_errors);
3339 if (temp_64 > 0xFFUL)
3340 p->port_xmit_constraint_errors = 0xFF;
3341 else
3342 p->port_xmit_constraint_errors = (u8)temp_64;
3343
3344 temp_64 = be64_to_cpu(rsp.port_rcv_constraint_errors);
3345 if (temp_64 > 0xFFUL)
3346 p->port_rcv_constraint_errors = 0xFFUL;
3347 else
3348 p->port_rcv_constraint_errors = (u8)temp_64;
3349
3350
3351 temp_64 = be64_to_cpu(rsp.local_link_integrity_errors);
3352 if (temp_64 > 0xFUL)
3353 temp_64 = 0xFUL;
3354
3355 temp_link_overrun_errors = temp_64 << 4;
3356
3357 temp_64 = be64_to_cpu(rsp.excessive_buffer_overruns);
3358 if (temp_64 > 0xFUL)
3359 temp_64 = 0xFUL;
3360 temp_link_overrun_errors |= temp_64;
3361
3362 p->link_overrun_errors = (u8)temp_link_overrun_errors;
3363
3364 p->vl15_dropped = 0;
3365
3366bail:
3367 return reply((struct ib_mad_hdr *)pmp);
3368}
3369
3370static int pma_get_opa_errorinfo(struct opa_pma_mad *pmp,
3371 struct ib_device *ibdev,
3372 u32 port, u32 *resp_len)
3373{
3374 size_t response_data_size;
3375 struct _port_ei *rsp;
3376 struct opa_port_error_info_msg *req;
3377 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
3378 u64 port_mask;
3379 u32 num_ports;
3380 u32 port_num;
3381 u8 num_pslm;
3382 u64 reg;
3383
3384 req = (struct opa_port_error_info_msg *)pmp->data;
3385 rsp = &req->port[0];
3386
3387 num_ports = OPA_AM_NPORT(be32_to_cpu(pmp->mad_hdr.attr_mod));
3388 num_pslm = hweight64(be64_to_cpu(req->port_select_mask[3]));
3389
3390 memset(rsp, 0, sizeof(*rsp));
3391
3392 if (num_ports != 1 || num_ports != num_pslm) {
3393 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3394 return reply((struct ib_mad_hdr *)pmp);
3395 }
3396
3397
3398 response_data_size = sizeof(struct opa_port_error_info_msg);
3399
3400 if (response_data_size > sizeof(pmp->data)) {
3401 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3402 return reply((struct ib_mad_hdr *)pmp);
3403 }
3404
3405
3406
3407
3408
3409 port_mask = be64_to_cpu(req->port_select_mask[3]);
3410 port_num = find_first_bit((unsigned long *)&port_mask,
3411 sizeof(port_mask) * 8);
3412
3413 if (port_num != port) {
3414 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3415 return reply((struct ib_mad_hdr *)pmp);
3416 }
3417 rsp->port_number = port;
3418
3419
3420 rsp->port_rcv_ei.status_and_code =
3421 dd->err_info_rcvport.status_and_code;
3422 memcpy(&rsp->port_rcv_ei.ei.ei1to12.packet_flit1,
3423 &dd->err_info_rcvport.packet_flit1, sizeof(u64));
3424 memcpy(&rsp->port_rcv_ei.ei.ei1to12.packet_flit2,
3425 &dd->err_info_rcvport.packet_flit2, sizeof(u64));
3426
3427
3428 reg = read_csr(dd, RCV_ERR_INFO);
3429 if (reg & RCV_ERR_INFO_RCV_EXCESS_BUFFER_OVERRUN_SMASK) {
3430
3431
3432
3433
3434 u8 tmp = (u8)reg;
3435
3436 tmp &= RCV_ERR_INFO_RCV_EXCESS_BUFFER_OVERRUN_SC_SMASK;
3437 tmp <<= 2;
3438 rsp->excessive_buffer_overrun_ei.status_and_sc = tmp;
3439
3440 rsp->excessive_buffer_overrun_ei.status_and_sc |= 0x80;
3441 }
3442
3443 rsp->port_xmit_constraint_ei.status =
3444 dd->err_info_xmit_constraint.status;
3445 rsp->port_xmit_constraint_ei.pkey =
3446 cpu_to_be16(dd->err_info_xmit_constraint.pkey);
3447 rsp->port_xmit_constraint_ei.slid =
3448 cpu_to_be32(dd->err_info_xmit_constraint.slid);
3449
3450 rsp->port_rcv_constraint_ei.status =
3451 dd->err_info_rcv_constraint.status;
3452 rsp->port_rcv_constraint_ei.pkey =
3453 cpu_to_be16(dd->err_info_rcv_constraint.pkey);
3454 rsp->port_rcv_constraint_ei.slid =
3455 cpu_to_be32(dd->err_info_rcv_constraint.slid);
3456
3457
3458 rsp->uncorrectable_ei.status_and_code = dd->err_info_uncorrectable;
3459
3460
3461 rsp->fm_config_ei.status_and_code = dd->err_info_fmconfig;
3462
3463 if (resp_len)
3464 *resp_len += response_data_size;
3465
3466 return reply((struct ib_mad_hdr *)pmp);
3467}
3468
3469static int pma_set_opa_portstatus(struct opa_pma_mad *pmp,
3470 struct ib_device *ibdev,
3471 u32 port, u32 *resp_len)
3472{
3473 struct opa_clear_port_status *req =
3474 (struct opa_clear_port_status *)pmp->data;
3475 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
3476 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3477 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3478 u32 nports = be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24;
3479 u64 portn = be64_to_cpu(req->port_select_mask[3]);
3480 u32 counter_select = be32_to_cpu(req->counter_select_mask);
3481 unsigned long vl_select_mask = VL_MASK_ALL;
3482 unsigned long vl;
3483
3484 if ((nports != 1) || (portn != 1 << port)) {
3485 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3486 return reply((struct ib_mad_hdr *)pmp);
3487 }
3488
3489
3490
3491
3492
3493
3494 if (counter_select & CS_PORT_XMIT_DATA)
3495 write_dev_cntr(dd, C_DC_XMIT_FLITS, CNTR_INVALID_VL, 0);
3496
3497 if (counter_select & CS_PORT_RCV_DATA)
3498 write_dev_cntr(dd, C_DC_RCV_FLITS, CNTR_INVALID_VL, 0);
3499
3500 if (counter_select & CS_PORT_XMIT_PKTS)
3501 write_dev_cntr(dd, C_DC_XMIT_PKTS, CNTR_INVALID_VL, 0);
3502
3503 if (counter_select & CS_PORT_RCV_PKTS)
3504 write_dev_cntr(dd, C_DC_RCV_PKTS, CNTR_INVALID_VL, 0);
3505
3506 if (counter_select & CS_PORT_MCAST_XMIT_PKTS)
3507 write_dev_cntr(dd, C_DC_MC_XMIT_PKTS, CNTR_INVALID_VL, 0);
3508
3509 if (counter_select & CS_PORT_MCAST_RCV_PKTS)
3510 write_dev_cntr(dd, C_DC_MC_RCV_PKTS, CNTR_INVALID_VL, 0);
3511
3512 if (counter_select & CS_PORT_XMIT_WAIT) {
3513 write_port_cntr(ppd, C_TX_WAIT, CNTR_INVALID_VL, 0);
3514 ppd->port_vl_xmit_wait_last[C_VL_COUNT] = 0;
3515 ppd->vl_xmit_flit_cnt[C_VL_COUNT] = 0;
3516 }
3517
3518
3519 if (counter_select & CS_PORT_RCV_FECN)
3520 write_dev_cntr(dd, C_DC_RCV_FCN, CNTR_INVALID_VL, 0);
3521
3522 if (counter_select & CS_PORT_RCV_BECN)
3523 write_dev_cntr(dd, C_DC_RCV_BCN, CNTR_INVALID_VL, 0);
3524
3525
3526
3527
3528 if (counter_select & CS_PORT_RCV_BUBBLE)
3529 write_dev_cntr(dd, C_DC_RCV_BBL, CNTR_INVALID_VL, 0);
3530
3531
3532
3533
3534
3535
3536 if (counter_select & CS_PORT_RCV_CONSTRAINT_ERRORS)
3537 write_port_cntr(ppd, C_SW_RCV_CSTR_ERR, CNTR_INVALID_VL, 0);
3538
3539
3540 if (counter_select & CS_PORT_XMIT_DISCARDS)
3541 write_port_cntr(ppd, C_SW_XMIT_DSCD, CNTR_INVALID_VL, 0);
3542
3543 if (counter_select & CS_PORT_XMIT_CONSTRAINT_ERRORS)
3544 write_port_cntr(ppd, C_SW_XMIT_CSTR_ERR, CNTR_INVALID_VL, 0);
3545
3546 if (counter_select & CS_PORT_RCV_REMOTE_PHYSICAL_ERRORS)
3547 write_dev_cntr(dd, C_DC_RMT_PHY_ERR, CNTR_INVALID_VL, 0);
3548
3549 if (counter_select & CS_LOCAL_LINK_INTEGRITY_ERRORS)
3550 write_dev_cntr(dd, C_DC_RX_REPLAY, CNTR_INVALID_VL, 0);
3551
3552 if (counter_select & CS_LINK_ERROR_RECOVERY) {
3553 write_dev_cntr(dd, C_DC_SEQ_CRC_CNT, CNTR_INVALID_VL, 0);
3554 write_dev_cntr(dd, C_DC_REINIT_FROM_PEER_CNT,
3555 CNTR_INVALID_VL, 0);
3556 }
3557
3558 if (counter_select & CS_PORT_RCV_ERRORS)
3559 write_dev_cntr(dd, C_DC_RCV_ERR, CNTR_INVALID_VL, 0);
3560
3561 if (counter_select & CS_EXCESSIVE_BUFFER_OVERRUNS) {
3562 write_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL, 0);
3563 dd->rcv_ovfl_cnt = 0;
3564 }
3565
3566 if (counter_select & CS_FM_CONFIG_ERRORS)
3567 write_dev_cntr(dd, C_DC_FM_CFG_ERR, CNTR_INVALID_VL, 0);
3568
3569 if (counter_select & CS_LINK_DOWNED)
3570 write_port_cntr(ppd, C_SW_LINK_DOWN, CNTR_INVALID_VL, 0);
3571
3572 if (counter_select & CS_UNCORRECTABLE_ERRORS)
3573 write_dev_cntr(dd, C_DC_UNC_ERR, CNTR_INVALID_VL, 0);
3574
3575 for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
3576 if (counter_select & CS_PORT_XMIT_DATA)
3577 write_port_cntr(ppd, C_TX_FLIT_VL, idx_from_vl(vl), 0);
3578
3579 if (counter_select & CS_PORT_RCV_DATA)
3580 write_dev_cntr(dd, C_DC_RX_FLIT_VL, idx_from_vl(vl), 0);
3581
3582 if (counter_select & CS_PORT_XMIT_PKTS)
3583 write_port_cntr(ppd, C_TX_PKT_VL, idx_from_vl(vl), 0);
3584
3585 if (counter_select & CS_PORT_RCV_PKTS)
3586 write_dev_cntr(dd, C_DC_RX_PKT_VL, idx_from_vl(vl), 0);
3587
3588 if (counter_select & CS_PORT_XMIT_WAIT) {
3589 write_port_cntr(ppd, C_TX_WAIT_VL, idx_from_vl(vl), 0);
3590 ppd->port_vl_xmit_wait_last[idx_from_vl(vl)] = 0;
3591 ppd->vl_xmit_flit_cnt[idx_from_vl(vl)] = 0;
3592 }
3593
3594
3595 if (counter_select & CS_PORT_RCV_FECN)
3596 write_dev_cntr(dd, C_DC_RCV_FCN_VL, idx_from_vl(vl), 0);
3597
3598 if (counter_select & CS_PORT_RCV_BECN)
3599 write_dev_cntr(dd, C_DC_RCV_BCN_VL, idx_from_vl(vl), 0);
3600
3601
3602
3603
3604 if (counter_select & CS_PORT_RCV_BUBBLE)
3605 write_dev_cntr(dd, C_DC_RCV_BBL_VL, idx_from_vl(vl), 0);
3606
3607
3608
3609
3610 if (counter_select & C_SW_XMIT_DSCD_VL)
3611 write_port_cntr(ppd, C_SW_XMIT_DSCD_VL,
3612 idx_from_vl(vl), 0);
3613 }
3614
3615 if (resp_len)
3616 *resp_len += sizeof(*req);
3617
3618 return reply((struct ib_mad_hdr *)pmp);
3619}
3620
3621static int pma_set_opa_errorinfo(struct opa_pma_mad *pmp,
3622 struct ib_device *ibdev,
3623 u32 port, u32 *resp_len)
3624{
3625 struct _port_ei *rsp;
3626 struct opa_port_error_info_msg *req;
3627 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
3628 u64 port_mask;
3629 u32 num_ports;
3630 u32 port_num;
3631 u8 num_pslm;
3632 u32 error_info_select;
3633
3634 req = (struct opa_port_error_info_msg *)pmp->data;
3635 rsp = &req->port[0];
3636
3637 num_ports = OPA_AM_NPORT(be32_to_cpu(pmp->mad_hdr.attr_mod));
3638 num_pslm = hweight64(be64_to_cpu(req->port_select_mask[3]));
3639
3640 memset(rsp, 0, sizeof(*rsp));
3641
3642 if (num_ports != 1 || num_ports != num_pslm) {
3643 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3644 return reply((struct ib_mad_hdr *)pmp);
3645 }
3646
3647
3648
3649
3650
3651 port_mask = be64_to_cpu(req->port_select_mask[3]);
3652 port_num = find_first_bit((unsigned long *)&port_mask,
3653 sizeof(port_mask) * 8);
3654
3655 if (port_num != port) {
3656 pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
3657 return reply((struct ib_mad_hdr *)pmp);
3658 }
3659
3660 error_info_select = be32_to_cpu(req->error_info_select_mask);
3661
3662
3663 if (error_info_select & ES_PORT_RCV_ERROR_INFO)
3664
3665 dd->err_info_rcvport.status_and_code &= ~OPA_EI_STATUS_SMASK;
3666
3667
3668 if (error_info_select & ES_EXCESSIVE_BUFFER_OVERRUN_INFO)
3669
3670
3671
3672
3673 write_csr(dd, RCV_ERR_INFO,
3674 RCV_ERR_INFO_RCV_EXCESS_BUFFER_OVERRUN_SMASK);
3675
3676 if (error_info_select & ES_PORT_XMIT_CONSTRAINT_ERROR_INFO)
3677 dd->err_info_xmit_constraint.status &= ~OPA_EI_STATUS_SMASK;
3678
3679 if (error_info_select & ES_PORT_RCV_CONSTRAINT_ERROR_INFO)
3680 dd->err_info_rcv_constraint.status &= ~OPA_EI_STATUS_SMASK;
3681
3682
3683 if (error_info_select & ES_UNCORRECTABLE_ERROR_INFO)
3684
3685 dd->err_info_uncorrectable &= ~OPA_EI_STATUS_SMASK;
3686
3687
3688 if (error_info_select & ES_FM_CONFIG_ERROR_INFO)
3689
3690 dd->err_info_fmconfig &= ~OPA_EI_STATUS_SMASK;
3691
3692 if (resp_len)
3693 *resp_len += sizeof(*req);
3694
3695 return reply((struct ib_mad_hdr *)pmp);
3696}
3697
3698struct opa_congestion_info_attr {
3699 __be16 congestion_info;
3700 u8 control_table_cap;
3701 u8 congestion_log_length;
3702} __packed;
3703
3704static int __subn_get_opa_cong_info(struct opa_smp *smp, u32 am, u8 *data,
3705 struct ib_device *ibdev, u32 port,
3706 u32 *resp_len, u32 max_len)
3707{
3708 struct opa_congestion_info_attr *p =
3709 (struct opa_congestion_info_attr *)data;
3710 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3711 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3712
3713 if (smp_length_check(sizeof(*p), max_len)) {
3714 smp->status |= IB_SMP_INVALID_FIELD;
3715 return reply((struct ib_mad_hdr *)smp);
3716 }
3717
3718 p->congestion_info = 0;
3719 p->control_table_cap = ppd->cc_max_table_entries;
3720 p->congestion_log_length = OPA_CONG_LOG_ELEMS;
3721
3722 if (resp_len)
3723 *resp_len += sizeof(*p);
3724
3725 return reply((struct ib_mad_hdr *)smp);
3726}
3727
3728static int __subn_get_opa_cong_setting(struct opa_smp *smp, u32 am,
3729 u8 *data, struct ib_device *ibdev,
3730 u32 port, u32 *resp_len, u32 max_len)
3731{
3732 int i;
3733 struct opa_congestion_setting_attr *p =
3734 (struct opa_congestion_setting_attr *)data;
3735 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3736 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3737 struct opa_congestion_setting_entry_shadow *entries;
3738 struct cc_state *cc_state;
3739
3740 if (smp_length_check(sizeof(*p), max_len)) {
3741 smp->status |= IB_SMP_INVALID_FIELD;
3742 return reply((struct ib_mad_hdr *)smp);
3743 }
3744
3745 rcu_read_lock();
3746
3747 cc_state = get_cc_state(ppd);
3748
3749 if (!cc_state) {
3750 rcu_read_unlock();
3751 return reply((struct ib_mad_hdr *)smp);
3752 }
3753
3754 entries = cc_state->cong_setting.entries;
3755 p->port_control = cpu_to_be16(cc_state->cong_setting.port_control);
3756 p->control_map = cpu_to_be32(cc_state->cong_setting.control_map);
3757 for (i = 0; i < OPA_MAX_SLS; i++) {
3758 p->entries[i].ccti_increase = entries[i].ccti_increase;
3759 p->entries[i].ccti_timer = cpu_to_be16(entries[i].ccti_timer);
3760 p->entries[i].trigger_threshold =
3761 entries[i].trigger_threshold;
3762 p->entries[i].ccti_min = entries[i].ccti_min;
3763 }
3764
3765 rcu_read_unlock();
3766
3767 if (resp_len)
3768 *resp_len += sizeof(*p);
3769
3770 return reply((struct ib_mad_hdr *)smp);
3771}
3772
3773
3774
3775
3776
3777static void apply_cc_state(struct hfi1_pportdata *ppd)
3778{
3779 struct cc_state *old_cc_state, *new_cc_state;
3780
3781 new_cc_state = kzalloc(sizeof(*new_cc_state), GFP_KERNEL);
3782 if (!new_cc_state)
3783 return;
3784
3785
3786
3787
3788
3789 spin_lock(&ppd->cc_state_lock);
3790
3791 old_cc_state = get_cc_state_protected(ppd);
3792 if (!old_cc_state) {
3793
3794 spin_unlock(&ppd->cc_state_lock);
3795 kfree(new_cc_state);
3796 return;
3797 }
3798
3799 *new_cc_state = *old_cc_state;
3800
3801 if (ppd->total_cct_entry)
3802 new_cc_state->cct.ccti_limit = ppd->total_cct_entry - 1;
3803 else
3804 new_cc_state->cct.ccti_limit = 0;
3805
3806 memcpy(new_cc_state->cct.entries, ppd->ccti_entries,
3807 ppd->total_cct_entry * sizeof(struct ib_cc_table_entry));
3808
3809 new_cc_state->cong_setting.port_control = IB_CC_CCS_PC_SL_BASED;
3810 new_cc_state->cong_setting.control_map = ppd->cc_sl_control_map;
3811 memcpy(new_cc_state->cong_setting.entries, ppd->congestion_entries,
3812 OPA_MAX_SLS * sizeof(struct opa_congestion_setting_entry));
3813
3814 rcu_assign_pointer(ppd->cc_state, new_cc_state);
3815
3816 spin_unlock(&ppd->cc_state_lock);
3817
3818 kfree_rcu(old_cc_state, rcu);
3819}
3820
3821static int __subn_set_opa_cong_setting(struct opa_smp *smp, u32 am, u8 *data,
3822 struct ib_device *ibdev, u32 port,
3823 u32 *resp_len, u32 max_len)
3824{
3825 struct opa_congestion_setting_attr *p =
3826 (struct opa_congestion_setting_attr *)data;
3827 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3828 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3829 struct opa_congestion_setting_entry_shadow *entries;
3830 int i;
3831
3832 if (smp_length_check(sizeof(*p), max_len)) {
3833 smp->status |= IB_SMP_INVALID_FIELD;
3834 return reply((struct ib_mad_hdr *)smp);
3835 }
3836
3837
3838
3839
3840
3841 spin_lock(&ppd->cc_state_lock);
3842 ppd->cc_sl_control_map = be32_to_cpu(p->control_map);
3843
3844 entries = ppd->congestion_entries;
3845 for (i = 0; i < OPA_MAX_SLS; i++) {
3846 entries[i].ccti_increase = p->entries[i].ccti_increase;
3847 entries[i].ccti_timer = be16_to_cpu(p->entries[i].ccti_timer);
3848 entries[i].trigger_threshold =
3849 p->entries[i].trigger_threshold;
3850 entries[i].ccti_min = p->entries[i].ccti_min;
3851 }
3852 spin_unlock(&ppd->cc_state_lock);
3853
3854
3855 apply_cc_state(ppd);
3856
3857 return __subn_get_opa_cong_setting(smp, am, data, ibdev, port,
3858 resp_len, max_len);
3859}
3860
3861static int __subn_get_opa_hfi1_cong_log(struct opa_smp *smp, u32 am,
3862 u8 *data, struct ib_device *ibdev,
3863 u32 port, u32 *resp_len, u32 max_len)
3864{
3865 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3866 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3867 struct opa_hfi1_cong_log *cong_log = (struct opa_hfi1_cong_log *)data;
3868 u64 ts;
3869 int i;
3870
3871 if (am || smp_length_check(sizeof(*cong_log), max_len)) {
3872 smp->status |= IB_SMP_INVALID_FIELD;
3873 return reply((struct ib_mad_hdr *)smp);
3874 }
3875
3876 spin_lock_irq(&ppd->cc_log_lock);
3877
3878 cong_log->log_type = OPA_CC_LOG_TYPE_HFI;
3879 cong_log->congestion_flags = 0;
3880 cong_log->threshold_event_counter =
3881 cpu_to_be16(ppd->threshold_event_counter);
3882 memcpy(cong_log->threshold_cong_event_map,
3883 ppd->threshold_cong_event_map,
3884 sizeof(cong_log->threshold_cong_event_map));
3885
3886 ts = ktime_get_ns() / 1024;
3887 cong_log->current_time_stamp = cpu_to_be32(ts);
3888 for (i = 0; i < OPA_CONG_LOG_ELEMS; i++) {
3889 struct opa_hfi1_cong_log_event_internal *cce =
3890 &ppd->cc_events[ppd->cc_mad_idx++];
3891 if (ppd->cc_mad_idx == OPA_CONG_LOG_ELEMS)
3892 ppd->cc_mad_idx = 0;
3893
3894
3895
3896
3897
3898 if ((ts - cce->timestamp) / 2 > U32_MAX)
3899 continue;
3900 memcpy(cong_log->events[i].local_qp_cn_entry, &cce->lqpn, 3);
3901 memcpy(cong_log->events[i].remote_qp_number_cn_entry,
3902 &cce->rqpn, 3);
3903 cong_log->events[i].sl_svc_type_cn_entry =
3904 ((cce->sl & 0x1f) << 3) | (cce->svc_type & 0x7);
3905 cong_log->events[i].remote_lid_cn_entry =
3906 cpu_to_be32(cce->rlid);
3907 cong_log->events[i].timestamp_cn_entry =
3908 cpu_to_be32(cce->timestamp);
3909 }
3910
3911
3912
3913
3914
3915 memset(ppd->threshold_cong_event_map, 0x0,
3916 sizeof(ppd->threshold_cong_event_map));
3917 ppd->threshold_event_counter = 0;
3918
3919 spin_unlock_irq(&ppd->cc_log_lock);
3920
3921 if (resp_len)
3922 *resp_len += sizeof(struct opa_hfi1_cong_log);
3923
3924 return reply((struct ib_mad_hdr *)smp);
3925}
3926
3927static int __subn_get_opa_cc_table(struct opa_smp *smp, u32 am, u8 *data,
3928 struct ib_device *ibdev, u32 port,
3929 u32 *resp_len, u32 max_len)
3930{
3931 struct ib_cc_table_attr *cc_table_attr =
3932 (struct ib_cc_table_attr *)data;
3933 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3934 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3935 u32 start_block = OPA_AM_START_BLK(am);
3936 u32 n_blocks = OPA_AM_NBLK(am);
3937 struct ib_cc_table_entry_shadow *entries;
3938 int i, j;
3939 u32 sentry, eentry;
3940 struct cc_state *cc_state;
3941 u32 size = sizeof(u16) * (IB_CCT_ENTRIES * n_blocks + 1);
3942
3943
3944 if (n_blocks == 0 || smp_length_check(size, max_len) ||
3945 start_block + n_blocks > ppd->cc_max_table_entries) {
3946 smp->status |= IB_SMP_INVALID_FIELD;
3947 return reply((struct ib_mad_hdr *)smp);
3948 }
3949
3950 rcu_read_lock();
3951
3952 cc_state = get_cc_state(ppd);
3953
3954 if (!cc_state) {
3955 rcu_read_unlock();
3956 return reply((struct ib_mad_hdr *)smp);
3957 }
3958
3959 sentry = start_block * IB_CCT_ENTRIES;
3960 eentry = sentry + (IB_CCT_ENTRIES * n_blocks);
3961
3962 cc_table_attr->ccti_limit = cpu_to_be16(cc_state->cct.ccti_limit);
3963
3964 entries = cc_state->cct.entries;
3965
3966
3967 for (j = 0, i = sentry; i < eentry; j++, i++)
3968 cc_table_attr->ccti_entries[j].entry =
3969 cpu_to_be16(entries[i].entry);
3970
3971 rcu_read_unlock();
3972
3973 if (resp_len)
3974 *resp_len += size;
3975
3976 return reply((struct ib_mad_hdr *)smp);
3977}
3978
3979static int __subn_set_opa_cc_table(struct opa_smp *smp, u32 am, u8 *data,
3980 struct ib_device *ibdev, u32 port,
3981 u32 *resp_len, u32 max_len)
3982{
3983 struct ib_cc_table_attr *p = (struct ib_cc_table_attr *)data;
3984 struct hfi1_ibport *ibp = to_iport(ibdev, port);
3985 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
3986 u32 start_block = OPA_AM_START_BLK(am);
3987 u32 n_blocks = OPA_AM_NBLK(am);
3988 struct ib_cc_table_entry_shadow *entries;
3989 int i, j;
3990 u32 sentry, eentry;
3991 u16 ccti_limit;
3992 u32 size = sizeof(u16) * (IB_CCT_ENTRIES * n_blocks + 1);
3993
3994
3995 if (n_blocks == 0 || smp_length_check(size, max_len) ||
3996 start_block + n_blocks > ppd->cc_max_table_entries) {
3997 smp->status |= IB_SMP_INVALID_FIELD;
3998 return reply((struct ib_mad_hdr *)smp);
3999 }
4000
4001 sentry = start_block * IB_CCT_ENTRIES;
4002 eentry = sentry + ((n_blocks - 1) * IB_CCT_ENTRIES) +
4003 (be16_to_cpu(p->ccti_limit)) % IB_CCT_ENTRIES + 1;
4004
4005
4006 ccti_limit = be16_to_cpu(p->ccti_limit);
4007 if (ccti_limit + 1 > eentry) {
4008 smp->status |= IB_SMP_INVALID_FIELD;
4009 return reply((struct ib_mad_hdr *)smp);
4010 }
4011
4012
4013
4014
4015
4016 spin_lock(&ppd->cc_state_lock);
4017 ppd->total_cct_entry = ccti_limit + 1;
4018 entries = ppd->ccti_entries;
4019 for (j = 0, i = sentry; i < eentry; j++, i++)
4020 entries[i].entry = be16_to_cpu(p->ccti_entries[j].entry);
4021 spin_unlock(&ppd->cc_state_lock);
4022
4023
4024 apply_cc_state(ppd);
4025
4026 return __subn_get_opa_cc_table(smp, am, data, ibdev, port, resp_len,
4027 max_len);
4028}
4029
4030struct opa_led_info {
4031 __be32 rsvd_led_mask;
4032 __be32 rsvd;
4033};
4034
4035#define OPA_LED_SHIFT 31
4036#define OPA_LED_MASK BIT(OPA_LED_SHIFT)
4037
4038static int __subn_get_opa_led_info(struct opa_smp *smp, u32 am, u8 *data,
4039 struct ib_device *ibdev, u32 port,
4040 u32 *resp_len, u32 max_len)
4041{
4042 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
4043 struct hfi1_pportdata *ppd = dd->pport;
4044 struct opa_led_info *p = (struct opa_led_info *)data;
4045 u32 nport = OPA_AM_NPORT(am);
4046 u32 is_beaconing_active;
4047
4048 if (nport != 1 || smp_length_check(sizeof(*p), max_len)) {
4049 smp->status |= IB_SMP_INVALID_FIELD;
4050 return reply((struct ib_mad_hdr *)smp);
4051 }
4052
4053
4054
4055
4056
4057
4058 smp_rmb();
4059 is_beaconing_active = !!atomic_read(&ppd->led_override_timer_active);
4060 p->rsvd_led_mask = cpu_to_be32(is_beaconing_active << OPA_LED_SHIFT);
4061
4062 if (resp_len)
4063 *resp_len += sizeof(struct opa_led_info);
4064
4065 return reply((struct ib_mad_hdr *)smp);
4066}
4067
4068static int __subn_set_opa_led_info(struct opa_smp *smp, u32 am, u8 *data,
4069 struct ib_device *ibdev, u32 port,
4070 u32 *resp_len, u32 max_len)
4071{
4072 struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
4073 struct opa_led_info *p = (struct opa_led_info *)data;
4074 u32 nport = OPA_AM_NPORT(am);
4075 int on = !!(be32_to_cpu(p->rsvd_led_mask) & OPA_LED_MASK);
4076
4077 if (nport != 1 || smp_length_check(sizeof(*p), max_len)) {
4078 smp->status |= IB_SMP_INVALID_FIELD;
4079 return reply((struct ib_mad_hdr *)smp);
4080 }
4081
4082 if (on)
4083 hfi1_start_led_override(dd->pport, 2000, 1500);
4084 else
4085 shutdown_led_override(dd->pport);
4086
4087 return __subn_get_opa_led_info(smp, am, data, ibdev, port, resp_len,
4088 max_len);
4089}
4090
4091static int subn_get_opa_sma(__be16 attr_id, struct opa_smp *smp, u32 am,
4092 u8 *data, struct ib_device *ibdev, u32 port,
4093 u32 *resp_len, u32 max_len)
4094{
4095 int ret;
4096 struct hfi1_ibport *ibp = to_iport(ibdev, port);
4097
4098 switch (attr_id) {
4099 case IB_SMP_ATTR_NODE_DESC:
4100 ret = __subn_get_opa_nodedesc(smp, am, data, ibdev, port,
4101 resp_len, max_len);
4102 break;
4103 case IB_SMP_ATTR_NODE_INFO:
4104 ret = __subn_get_opa_nodeinfo(smp, am, data, ibdev, port,
4105 resp_len, max_len);
4106 break;
4107 case IB_SMP_ATTR_PORT_INFO:
4108 ret = __subn_get_opa_portinfo(smp, am, data, ibdev, port,
4109 resp_len, max_len);
4110 break;
4111 case IB_SMP_ATTR_PKEY_TABLE:
4112 ret = __subn_get_opa_pkeytable(smp, am, data, ibdev, port,
4113 resp_len, max_len);
4114 break;
4115 case OPA_ATTRIB_ID_SL_TO_SC_MAP:
4116 ret = __subn_get_opa_sl_to_sc(smp, am, data, ibdev, port,
4117 resp_len, max_len);
4118 break;
4119 case OPA_ATTRIB_ID_SC_TO_SL_MAP:
4120 ret = __subn_get_opa_sc_to_sl(smp, am, data, ibdev, port,
4121 resp_len, max_len);
4122 break;
4123 case OPA_ATTRIB_ID_SC_TO_VLT_MAP:
4124 ret = __subn_get_opa_sc_to_vlt(smp, am, data, ibdev, port,
4125 resp_len, max_len);
4126 break;
4127 case OPA_ATTRIB_ID_SC_TO_VLNT_MAP:
4128 ret = __subn_get_opa_sc_to_vlnt(smp, am, data, ibdev, port,
4129 resp_len, max_len);
4130 break;
4131 case OPA_ATTRIB_ID_PORT_STATE_INFO:
4132 ret = __subn_get_opa_psi(smp, am, data, ibdev, port,
4133 resp_len, max_len);
4134 break;
4135 case OPA_ATTRIB_ID_BUFFER_CONTROL_TABLE:
4136 ret = __subn_get_opa_bct(smp, am, data, ibdev, port,
4137 resp_len, max_len);
4138 break;
4139 case OPA_ATTRIB_ID_CABLE_INFO:
4140 ret = __subn_get_opa_cable_info(smp, am, data, ibdev, port,
4141 resp_len, max_len);
4142 break;
4143 case IB_SMP_ATTR_VL_ARB_TABLE:
4144 ret = __subn_get_opa_vl_arb(smp, am, data, ibdev, port,
4145 resp_len, max_len);
4146 break;
4147 case OPA_ATTRIB_ID_CONGESTION_INFO:
4148 ret = __subn_get_opa_cong_info(smp, am, data, ibdev, port,
4149 resp_len, max_len);
4150 break;
4151 case OPA_ATTRIB_ID_HFI_CONGESTION_SETTING:
4152 ret = __subn_get_opa_cong_setting(smp, am, data, ibdev,
4153 port, resp_len, max_len);
4154 break;
4155 case OPA_ATTRIB_ID_HFI_CONGESTION_LOG:
4156 ret = __subn_get_opa_hfi1_cong_log(smp, am, data, ibdev,
4157 port, resp_len, max_len);
4158 break;
4159 case OPA_ATTRIB_ID_CONGESTION_CONTROL_TABLE:
4160 ret = __subn_get_opa_cc_table(smp, am, data, ibdev, port,
4161 resp_len, max_len);
4162 break;
4163 case IB_SMP_ATTR_LED_INFO:
4164 ret = __subn_get_opa_led_info(smp, am, data, ibdev, port,
4165 resp_len, max_len);
4166 break;
4167 case IB_SMP_ATTR_SM_INFO:
4168 if (ibp->rvp.port_cap_flags & IB_PORT_SM_DISABLED)
4169 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
4170 if (ibp->rvp.port_cap_flags & IB_PORT_SM)
4171 return IB_MAD_RESULT_SUCCESS;
4172 fallthrough;
4173 default:
4174 smp->status |= IB_SMP_UNSUP_METH_ATTR;
4175 ret = reply((struct ib_mad_hdr *)smp);
4176 break;
4177 }
4178 return ret;
4179}
4180
4181static int subn_set_opa_sma(__be16 attr_id, struct opa_smp *smp, u32 am,
4182 u8 *data, struct ib_device *ibdev, u32 port,
4183 u32 *resp_len, u32 max_len, int local_mad)
4184{
4185 int ret;
4186 struct hfi1_ibport *ibp = to_iport(ibdev, port);
4187
4188 switch (attr_id) {
4189 case IB_SMP_ATTR_PORT_INFO:
4190 ret = __subn_set_opa_portinfo(smp, am, data, ibdev, port,
4191 resp_len, max_len, local_mad);
4192 break;
4193 case IB_SMP_ATTR_PKEY_TABLE:
4194 ret = __subn_set_opa_pkeytable(smp, am, data, ibdev, port,
4195 resp_len, max_len);
4196 break;
4197 case OPA_ATTRIB_ID_SL_TO_SC_MAP:
4198 ret = __subn_set_opa_sl_to_sc(smp, am, data, ibdev, port,
4199 resp_len, max_len);
4200 break;
4201 case OPA_ATTRIB_ID_SC_TO_SL_MAP:
4202 ret = __subn_set_opa_sc_to_sl(smp, am, data, ibdev, port,
4203 resp_len, max_len);
4204 break;
4205 case OPA_ATTRIB_ID_SC_TO_VLT_MAP:
4206 ret = __subn_set_opa_sc_to_vlt(smp, am, data, ibdev, port,
4207 resp_len, max_len);
4208 break;
4209 case OPA_ATTRIB_ID_SC_TO_VLNT_MAP:
4210 ret = __subn_set_opa_sc_to_vlnt(smp, am, data, ibdev, port,
4211 resp_len, max_len);
4212 break;
4213 case OPA_ATTRIB_ID_PORT_STATE_INFO:
4214 ret = __subn_set_opa_psi(smp, am, data, ibdev, port,
4215 resp_len, max_len, local_mad);
4216 break;
4217 case OPA_ATTRIB_ID_BUFFER_CONTROL_TABLE:
4218 ret = __subn_set_opa_bct(smp, am, data, ibdev, port,
4219 resp_len, max_len);
4220 break;
4221 case IB_SMP_ATTR_VL_ARB_TABLE:
4222 ret = __subn_set_opa_vl_arb(smp, am, data, ibdev, port,
4223 resp_len, max_len);
4224 break;
4225 case OPA_ATTRIB_ID_HFI_CONGESTION_SETTING:
4226 ret = __subn_set_opa_cong_setting(smp, am, data, ibdev,
4227 port, resp_len, max_len);
4228 break;
4229 case OPA_ATTRIB_ID_CONGESTION_CONTROL_TABLE:
4230 ret = __subn_set_opa_cc_table(smp, am, data, ibdev, port,
4231 resp_len, max_len);
4232 break;
4233 case IB_SMP_ATTR_LED_INFO:
4234 ret = __subn_set_opa_led_info(smp, am, data, ibdev, port,
4235 resp_len, max_len);
4236 break;
4237 case IB_SMP_ATTR_SM_INFO:
4238 if (ibp->rvp.port_cap_flags & IB_PORT_SM_DISABLED)
4239 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
4240 if (ibp->rvp.port_cap_flags & IB_PORT_SM)
4241 return IB_MAD_RESULT_SUCCESS;
4242 fallthrough;
4243 default:
4244 smp->status |= IB_SMP_UNSUP_METH_ATTR;
4245 ret = reply((struct ib_mad_hdr *)smp);
4246 break;
4247 }
4248 return ret;
4249}
4250
4251static inline void set_aggr_error(struct opa_aggregate *ag)
4252{
4253 ag->err_reqlength |= cpu_to_be16(0x8000);
4254}
4255
4256static int subn_get_opa_aggregate(struct opa_smp *smp,
4257 struct ib_device *ibdev, u32 port,
4258 u32 *resp_len)
4259{
4260 int i;
4261 u32 num_attr = be32_to_cpu(smp->attr_mod) & 0x000000ff;
4262 u8 *next_smp = opa_get_smp_data(smp);
4263
4264 if (num_attr < 1 || num_attr > 117) {
4265 smp->status |= IB_SMP_INVALID_FIELD;
4266 return reply((struct ib_mad_hdr *)smp);
4267 }
4268
4269 for (i = 0; i < num_attr; i++) {
4270 struct opa_aggregate *agg;
4271 size_t agg_data_len;
4272 size_t agg_size;
4273 u32 am;
4274
4275 agg = (struct opa_aggregate *)next_smp;
4276 agg_data_len = (be16_to_cpu(agg->err_reqlength) & 0x007f) * 8;
4277 agg_size = sizeof(*agg) + agg_data_len;
4278 am = be32_to_cpu(agg->attr_mod);
4279
4280 *resp_len += agg_size;
4281
4282 if (next_smp + agg_size > ((u8 *)smp) + sizeof(*smp)) {
4283 smp->status |= IB_SMP_INVALID_FIELD;
4284 return reply((struct ib_mad_hdr *)smp);
4285 }
4286
4287
4288 memset(next_smp + sizeof(*agg), 0, agg_data_len);
4289
4290 (void)subn_get_opa_sma(agg->attr_id, smp, am, agg->data,
4291 ibdev, port, NULL, (u32)agg_data_len);
4292
4293 if (smp->status & IB_SMP_INVALID_FIELD)
4294 break;
4295 if (smp->status & ~IB_SMP_DIRECTION) {
4296 set_aggr_error(agg);
4297 return reply((struct ib_mad_hdr *)smp);
4298 }
4299 next_smp += agg_size;
4300 }
4301
4302 return reply((struct ib_mad_hdr *)smp);
4303}
4304
4305static int subn_set_opa_aggregate(struct opa_smp *smp,
4306 struct ib_device *ibdev, u32 port,
4307 u32 *resp_len, int local_mad)
4308{
4309 int i;
4310 u32 num_attr = be32_to_cpu(smp->attr_mod) & 0x000000ff;
4311 u8 *next_smp = opa_get_smp_data(smp);
4312
4313 if (num_attr < 1 || num_attr > 117) {
4314 smp->status |= IB_SMP_INVALID_FIELD;
4315 return reply((struct ib_mad_hdr *)smp);
4316 }
4317
4318 for (i = 0; i < num_attr; i++) {
4319 struct opa_aggregate *agg;
4320 size_t agg_data_len;
4321 size_t agg_size;
4322 u32 am;
4323
4324 agg = (struct opa_aggregate *)next_smp;
4325 agg_data_len = (be16_to_cpu(agg->err_reqlength) & 0x007f) * 8;
4326 agg_size = sizeof(*agg) + agg_data_len;
4327 am = be32_to_cpu(agg->attr_mod);
4328
4329 *resp_len += agg_size;
4330
4331 if (next_smp + agg_size > ((u8 *)smp) + sizeof(*smp)) {
4332 smp->status |= IB_SMP_INVALID_FIELD;
4333 return reply((struct ib_mad_hdr *)smp);
4334 }
4335
4336 (void)subn_set_opa_sma(agg->attr_id, smp, am, agg->data,
4337 ibdev, port, NULL, (u32)agg_data_len,
4338 local_mad);
4339
4340 if (smp->status & IB_SMP_INVALID_FIELD)
4341 break;
4342 if (smp->status & ~IB_SMP_DIRECTION) {
4343 set_aggr_error(agg);
4344 return reply((struct ib_mad_hdr *)smp);
4345 }
4346 next_smp += agg_size;
4347 }
4348
4349 return reply((struct ib_mad_hdr *)smp);
4350}
4351
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363void clear_linkup_counters(struct hfi1_devdata *dd)
4364{
4365
4366 write_dev_cntr(dd, C_DC_RCV_ERR, CNTR_INVALID_VL, 0);
4367 dd->err_info_rcvport.status_and_code &= ~OPA_EI_STATUS_SMASK;
4368
4369 write_dev_cntr(dd, C_DC_SEQ_CRC_CNT, CNTR_INVALID_VL, 0);
4370 write_dev_cntr(dd, C_DC_REINIT_FROM_PEER_CNT, CNTR_INVALID_VL, 0);
4371
4372 write_dev_cntr(dd, C_DC_RX_REPLAY, CNTR_INVALID_VL, 0);
4373
4374 write_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL, 0);
4375 dd->rcv_ovfl_cnt = 0;
4376 dd->err_info_xmit_constraint.status &= ~OPA_EI_STATUS_SMASK;
4377}
4378
4379static int is_full_mgmt_pkey_in_table(struct hfi1_ibport *ibp)
4380{
4381 unsigned int i;
4382 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
4383
4384 for (i = 0; i < ARRAY_SIZE(ppd->pkeys); ++i)
4385 if (ppd->pkeys[i] == FULL_MGMT_P_KEY)
4386 return 1;
4387
4388 return 0;
4389}
4390
4391
4392
4393
4394
4395static int is_local_mad(struct hfi1_ibport *ibp, const struct opa_mad *mad,
4396 const struct ib_wc *in_wc)
4397{
4398 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
4399 const struct opa_smp *smp = (const struct opa_smp *)mad;
4400
4401 if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) {
4402 return (smp->hop_cnt == 0 &&
4403 smp->route.dr.dr_slid == OPA_LID_PERMISSIVE &&
4404 smp->route.dr.dr_dlid == OPA_LID_PERMISSIVE);
4405 }
4406
4407 return (in_wc->slid == ppd->lid);
4408}
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420static int opa_local_smp_check(struct hfi1_ibport *ibp,
4421 const struct ib_wc *in_wc)
4422{
4423 struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
4424 u16 pkey;
4425
4426 if (in_wc->pkey_index >= ARRAY_SIZE(ppd->pkeys))
4427 return 1;
4428
4429 pkey = ppd->pkeys[in_wc->pkey_index];
4430
4431
4432
4433
4434
4435
4436
4437
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447
4448 if (pkey == LIM_MGMT_P_KEY || pkey == FULL_MGMT_P_KEY)
4449 return 0;
4450 ingress_pkey_table_fail(ppd, pkey, in_wc->slid);
4451 return 1;
4452}
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478
4479
4480
4481
4482
4483
4484
4485
4486
4487
4488
4489
4490
4491static int hfi1_pkey_validation_pma(struct hfi1_ibport *ibp,
4492 const struct opa_mad *in_mad,
4493 const struct ib_wc *in_wc)
4494{
4495 u16 pkey_value = hfi1_lookup_pkey_value(ibp, in_wc->pkey_index);
4496
4497
4498 if (!is_local_mad(ibp, in_mad, in_wc) &&
4499 pkey_value != LIM_MGMT_P_KEY &&
4500 pkey_value != FULL_MGMT_P_KEY)
4501 return -EINVAL;
4502
4503
4504 if (pkey_value == LIM_MGMT_P_KEY &&
4505 is_full_mgmt_pkey_in_table(ibp))
4506 return -EINVAL;
4507
4508 return 0;
4509}
4510
4511static int process_subn_opa(struct ib_device *ibdev, int mad_flags,
4512 u32 port, const struct opa_mad *in_mad,
4513 struct opa_mad *out_mad,
4514 u32 *resp_len, int local_mad)
4515{
4516 struct opa_smp *smp = (struct opa_smp *)out_mad;
4517 struct hfi1_ibport *ibp = to_iport(ibdev, port);
4518 u8 *data;
4519 u32 am, data_size;
4520 __be16 attr_id;
4521 int ret;
4522
4523 *out_mad = *in_mad;
4524 data = opa_get_smp_data(smp);
4525 data_size = (u32)opa_get_smp_data_size(smp);
4526
4527 am = be32_to_cpu(smp->attr_mod);
4528 attr_id = smp->attr_id;
4529 if (smp->class_version != OPA_SM_CLASS_VERSION) {
4530 smp->status |= IB_SMP_UNSUP_VERSION;
4531 ret = reply((struct ib_mad_hdr *)smp);
4532 return ret;
4533 }
4534 ret = check_mkey(ibp, (struct ib_mad_hdr *)smp, mad_flags, smp->mkey,
4535 smp->route.dr.dr_slid, smp->route.dr.return_path,
4536 smp->hop_cnt);
4537 if (ret) {
4538 u32 port_num = be32_to_cpu(smp->attr_mod);
4539
4540
4541
4542
4543
4544
4545
4546
4547 if (attr_id == IB_SMP_ATTR_PORT_INFO &&
4548 (smp->method == IB_MGMT_METHOD_GET ||
4549 smp->method == IB_MGMT_METHOD_SET) &&
4550 port_num && port_num <= ibdev->phys_port_cnt &&
4551 port != port_num)
4552 (void)check_mkey(to_iport(ibdev, port_num),
4553 (struct ib_mad_hdr *)smp, 0,
4554 smp->mkey, smp->route.dr.dr_slid,
4555 smp->route.dr.return_path,
4556 smp->hop_cnt);
4557 ret = IB_MAD_RESULT_FAILURE;
4558 return ret;
4559 }
4560
4561 *resp_len = opa_get_smp_header_size(smp);
4562
4563 switch (smp->method) {
4564 case IB_MGMT_METHOD_GET:
4565 switch (attr_id) {
4566 default:
4567 clear_opa_smp_data(smp);
4568 ret = subn_get_opa_sma(attr_id, smp, am, data,
4569 ibdev, port, resp_len,
4570 data_size);
4571 break;
4572 case OPA_ATTRIB_ID_AGGREGATE:
4573 ret = subn_get_opa_aggregate(smp, ibdev, port,
4574 resp_len);
4575 break;
4576 }
4577 break;
4578 case IB_MGMT_METHOD_SET:
4579 switch (attr_id) {
4580 default:
4581 ret = subn_set_opa_sma(attr_id, smp, am, data,
4582 ibdev, port, resp_len,
4583 data_size, local_mad);
4584 break;
4585 case OPA_ATTRIB_ID_AGGREGATE:
4586 ret = subn_set_opa_aggregate(smp, ibdev, port,
4587 resp_len, local_mad);
4588 break;
4589 }
4590 break;
4591 case IB_MGMT_METHOD_TRAP:
4592 case IB_MGMT_METHOD_REPORT:
4593 case IB_MGMT_METHOD_REPORT_RESP:
4594 case IB_MGMT_METHOD_GET_RESP:
4595
4596
4597
4598
4599
4600 ret = IB_MAD_RESULT_SUCCESS;
4601 break;
4602 case IB_MGMT_METHOD_TRAP_REPRESS:
4603 subn_handle_opa_trap_repress(ibp, smp);
4604
4605 ret = IB_MAD_RESULT_SUCCESS;
4606 break;
4607 default:
4608 smp->status |= IB_SMP_UNSUP_METHOD;
4609 ret = reply((struct ib_mad_hdr *)smp);
4610 break;
4611 }
4612
4613 return ret;
4614}
4615
4616static int process_subn(struct ib_device *ibdev, int mad_flags,
4617 u32 port, const struct ib_mad *in_mad,
4618 struct ib_mad *out_mad)
4619{
4620 struct ib_smp *smp = (struct ib_smp *)out_mad;
4621 struct hfi1_ibport *ibp = to_iport(ibdev, port);
4622 int ret;
4623
4624 *out_mad = *in_mad;
4625 if (smp->class_version != 1) {
4626 smp->status |= IB_SMP_UNSUP_VERSION;
4627 ret = reply((struct ib_mad_hdr *)smp);
4628 return ret;
4629 }
4630
4631 ret = check_mkey(ibp, (struct ib_mad_hdr *)smp, mad_flags,
4632 smp->mkey, (__force __be32)smp->dr_slid,
4633 smp->return_path, smp->hop_cnt);
4634 if (ret) {
4635 u32 port_num = be32_to_cpu(smp->attr_mod);
4636
4637
4638
4639
4640
4641
4642
4643
4644 if (in_mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO &&
4645 (smp->method == IB_MGMT_METHOD_GET ||
4646 smp->method == IB_MGMT_METHOD_SET) &&
4647 port_num && port_num <= ibdev->phys_port_cnt &&
4648 port != port_num)
4649 (void)check_mkey(to_iport(ibdev, port_num),
4650 (struct ib_mad_hdr *)smp, 0,
4651 smp->mkey,
4652 (__force __be32)smp->dr_slid,
4653 smp->return_path, smp->hop_cnt);
4654 ret = IB_MAD_RESULT_FAILURE;
4655 return ret;
4656 }
4657
4658 switch (smp->method) {
4659 case IB_MGMT_METHOD_GET:
4660 switch (smp->attr_id) {
4661 case IB_SMP_ATTR_NODE_INFO:
4662 ret = subn_get_nodeinfo(smp, ibdev, port);
4663 break;
4664 default:
4665 smp->status |= IB_SMP_UNSUP_METH_ATTR;
4666 ret = reply((struct ib_mad_hdr *)smp);
4667 break;
4668 }
4669 break;
4670 }
4671
4672 return ret;
4673}
4674
4675static int process_perf(struct ib_device *ibdev, u32 port,
4676 const struct ib_mad *in_mad,
4677 struct ib_mad *out_mad)
4678{
4679 struct ib_pma_mad *pmp = (struct ib_pma_mad *)out_mad;
4680 struct ib_class_port_info *cpi = (struct ib_class_port_info *)
4681 &pmp->data;
4682 int ret = IB_MAD_RESULT_FAILURE;
4683
4684 *out_mad = *in_mad;
4685 if (pmp->mad_hdr.class_version != 1) {
4686 pmp->mad_hdr.status |= IB_SMP_UNSUP_VERSION;
4687 ret = reply((struct ib_mad_hdr *)pmp);
4688 return ret;
4689 }
4690
4691 switch (pmp->mad_hdr.method) {
4692 case IB_MGMT_METHOD_GET:
4693 switch (pmp->mad_hdr.attr_id) {
4694 case IB_PMA_PORT_COUNTERS:
4695 ret = pma_get_ib_portcounters(pmp, ibdev, port);
4696 break;
4697 case IB_PMA_PORT_COUNTERS_EXT:
4698 ret = pma_get_ib_portcounters_ext(pmp, ibdev, port);
4699 break;
4700 case IB_PMA_CLASS_PORT_INFO:
4701 cpi->capability_mask = IB_PMA_CLASS_CAP_EXT_WIDTH;
4702 ret = reply((struct ib_mad_hdr *)pmp);
4703 break;
4704 default:
4705 pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
4706 ret = reply((struct ib_mad_hdr *)pmp);
4707 break;
4708 }
4709 break;
4710
4711 case IB_MGMT_METHOD_SET:
4712 if (pmp->mad_hdr.attr_id) {
4713 pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
4714 ret = reply((struct ib_mad_hdr *)pmp);
4715 }
4716 break;
4717
4718 case IB_MGMT_METHOD_TRAP:
4719 case IB_MGMT_METHOD_GET_RESP:
4720
4721
4722
4723
4724
4725 ret = IB_MAD_RESULT_SUCCESS;
4726 break;
4727
4728 default:
4729 pmp->mad_hdr.status |= IB_SMP_UNSUP_METHOD;
4730 ret = reply((struct ib_mad_hdr *)pmp);
4731 break;
4732 }
4733
4734 return ret;
4735}
4736
4737static int process_perf_opa(struct ib_device *ibdev, u32 port,
4738 const struct opa_mad *in_mad,
4739 struct opa_mad *out_mad, u32 *resp_len)
4740{
4741 struct opa_pma_mad *pmp = (struct opa_pma_mad *)out_mad;
4742 int ret;
4743
4744 *out_mad = *in_mad;
4745
4746 if (pmp->mad_hdr.class_version != OPA_SM_CLASS_VERSION) {
4747 pmp->mad_hdr.status |= IB_SMP_UNSUP_VERSION;
4748 return reply((struct ib_mad_hdr *)pmp);
4749 }
4750
4751 *resp_len = sizeof(pmp->mad_hdr);
4752
4753 switch (pmp->mad_hdr.method) {
4754 case IB_MGMT_METHOD_GET:
4755 switch (pmp->mad_hdr.attr_id) {
4756 case IB_PMA_CLASS_PORT_INFO:
4757 ret = pma_get_opa_classportinfo(pmp, ibdev, resp_len);
4758 break;
4759 case OPA_PM_ATTRIB_ID_PORT_STATUS:
4760 ret = pma_get_opa_portstatus(pmp, ibdev, port,
4761 resp_len);
4762 break;
4763 case OPA_PM_ATTRIB_ID_DATA_PORT_COUNTERS:
4764 ret = pma_get_opa_datacounters(pmp, ibdev, port,
4765 resp_len);
4766 break;
4767 case OPA_PM_ATTRIB_ID_ERROR_PORT_COUNTERS:
4768 ret = pma_get_opa_porterrors(pmp, ibdev, port,
4769 resp_len);
4770 break;
4771 case OPA_PM_ATTRIB_ID_ERROR_INFO:
4772 ret = pma_get_opa_errorinfo(pmp, ibdev, port,
4773 resp_len);
4774 break;
4775 default:
4776 pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
4777 ret = reply((struct ib_mad_hdr *)pmp);
4778 break;
4779 }
4780 break;
4781
4782 case IB_MGMT_METHOD_SET:
4783 switch (pmp->mad_hdr.attr_id) {
4784 case OPA_PM_ATTRIB_ID_CLEAR_PORT_STATUS:
4785 ret = pma_set_opa_portstatus(pmp, ibdev, port,
4786 resp_len);
4787 break;
4788 case OPA_PM_ATTRIB_ID_ERROR_INFO:
4789 ret = pma_set_opa_errorinfo(pmp, ibdev, port,
4790 resp_len);
4791 break;
4792 default:
4793 pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
4794 ret = reply((struct ib_mad_hdr *)pmp);
4795 break;
4796 }
4797 break;
4798
4799 case IB_MGMT_METHOD_TRAP:
4800 case IB_MGMT_METHOD_GET_RESP:
4801
4802
4803
4804
4805
4806 ret = IB_MAD_RESULT_SUCCESS;
4807 break;
4808
4809 default:
4810 pmp->mad_hdr.status |= IB_SMP_UNSUP_METHOD;
4811 ret = reply((struct ib_mad_hdr *)pmp);
4812 break;
4813 }
4814
4815 return ret;
4816}
4817
4818static int hfi1_process_opa_mad(struct ib_device *ibdev, int mad_flags,
4819 u32 port, const struct ib_wc *in_wc,
4820 const struct ib_grh *in_grh,
4821 const struct opa_mad *in_mad,
4822 struct opa_mad *out_mad, size_t *out_mad_size,
4823 u16 *out_mad_pkey_index)
4824{
4825 int ret;
4826 int pkey_idx;
4827 int local_mad = 0;
4828 u32 resp_len = in_wc->byte_len - sizeof(*in_grh);
4829 struct hfi1_ibport *ibp = to_iport(ibdev, port);
4830
4831 pkey_idx = hfi1_lookup_pkey_idx(ibp, LIM_MGMT_P_KEY);
4832 if (pkey_idx < 0) {
4833 pr_warn("failed to find limited mgmt pkey, defaulting 0x%x\n",
4834 hfi1_get_pkey(ibp, 1));
4835 pkey_idx = 1;
4836 }
4837 *out_mad_pkey_index = (u16)pkey_idx;
4838
4839 switch (in_mad->mad_hdr.mgmt_class) {
4840 case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
4841 case IB_MGMT_CLASS_SUBN_LID_ROUTED:
4842 local_mad = is_local_mad(ibp, in_mad, in_wc);
4843 if (local_mad) {
4844 ret = opa_local_smp_check(ibp, in_wc);
4845 if (ret)
4846 return IB_MAD_RESULT_FAILURE;
4847 }
4848 ret = process_subn_opa(ibdev, mad_flags, port, in_mad,
4849 out_mad, &resp_len, local_mad);
4850 goto bail;
4851 case IB_MGMT_CLASS_PERF_MGMT:
4852 ret = hfi1_pkey_validation_pma(ibp, in_mad, in_wc);
4853 if (ret)
4854 return IB_MAD_RESULT_FAILURE;
4855
4856 ret = process_perf_opa(ibdev, port, in_mad, out_mad, &resp_len);
4857 goto bail;
4858
4859 default:
4860 ret = IB_MAD_RESULT_SUCCESS;
4861 }
4862
4863bail:
4864 if (ret & IB_MAD_RESULT_REPLY)
4865 *out_mad_size = round_up(resp_len, 8);
4866 else if (ret & IB_MAD_RESULT_SUCCESS)
4867 *out_mad_size = in_wc->byte_len - sizeof(struct ib_grh);
4868
4869 return ret;
4870}
4871
4872static int hfi1_process_ib_mad(struct ib_device *ibdev, int mad_flags, u32 port,
4873 const struct ib_wc *in_wc,
4874 const struct ib_grh *in_grh,
4875 const struct ib_mad *in_mad,
4876 struct ib_mad *out_mad)
4877{
4878 int ret;
4879
4880 switch (in_mad->mad_hdr.mgmt_class) {
4881 case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
4882 case IB_MGMT_CLASS_SUBN_LID_ROUTED:
4883 ret = process_subn(ibdev, mad_flags, port, in_mad, out_mad);
4884 break;
4885 case IB_MGMT_CLASS_PERF_MGMT:
4886 ret = process_perf(ibdev, port, in_mad, out_mad);
4887 break;
4888 default:
4889 ret = IB_MAD_RESULT_SUCCESS;
4890 break;
4891 }
4892
4893 return ret;
4894}
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917int hfi1_process_mad(struct ib_device *ibdev, int mad_flags, u32 port,
4918 const struct ib_wc *in_wc, const struct ib_grh *in_grh,
4919 const struct ib_mad *in_mad, struct ib_mad *out_mad,
4920 size_t *out_mad_size, u16 *out_mad_pkey_index)
4921{
4922 switch (in_mad->mad_hdr.base_version) {
4923 case OPA_MGMT_BASE_VERSION:
4924 return hfi1_process_opa_mad(ibdev, mad_flags, port,
4925 in_wc, in_grh,
4926 (struct opa_mad *)in_mad,
4927 (struct opa_mad *)out_mad,
4928 out_mad_size,
4929 out_mad_pkey_index);
4930 case IB_MGMT_BASE_VERSION:
4931 return hfi1_process_ib_mad(ibdev, mad_flags, port, in_wc,
4932 in_grh, in_mad, out_mad);
4933 default:
4934 break;
4935 }
4936
4937 return IB_MAD_RESULT_FAILURE;
4938}
4939