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