2 * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
4 * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * OpenIB.org BSD license below:
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
35 #include <rdma/ib_smi.h>
40 static int reply(struct ib_smp
*smp
)
43 * The verbs framework will handle the directed/LID route
46 smp
->method
= IB_MGMT_METHOD_GET_RESP
;
47 if (smp
->mgmt_class
== IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE
)
48 smp
->status
|= IB_SMP_DIRECTION
;
49 return IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_REPLY
;
52 static void qib_send_trap(struct qib_ibport
*ibp
, void *data
, unsigned len
)
54 struct ib_mad_send_buf
*send_buf
;
55 struct ib_mad_agent
*agent
;
59 unsigned long timeout
;
61 agent
= ibp
->send_agent
;
66 if (!(ppd_from_ibp(ibp
)->lflags
& QIBL_LINKACTIVE
))
70 if (ibp
->trap_timeout
&& time_before(jiffies
, ibp
->trap_timeout
))
73 send_buf
= ib_create_send_mad(agent
, 0, 0, 0, IB_MGMT_MAD_HDR
,
74 IB_MGMT_MAD_DATA
, GFP_ATOMIC
);
79 smp
->base_version
= IB_MGMT_BASE_VERSION
;
80 smp
->mgmt_class
= IB_MGMT_CLASS_SUBN_LID_ROUTED
;
81 smp
->class_version
= 1;
82 smp
->method
= IB_MGMT_METHOD_TRAP
;
84 smp
->tid
= cpu_to_be64(ibp
->tid
);
85 smp
->attr_id
= IB_SMP_ATTR_NOTICE
;
86 /* o14-1: smp->mkey = 0; */
87 memcpy(smp
->data
, data
, len
);
89 spin_lock_irqsave(&ibp
->lock
, flags
);
91 if (ibp
->sm_lid
!= be16_to_cpu(IB_LID_PERMISSIVE
)) {
93 struct ib_ah_attr attr
;
95 memset(&attr
, 0, sizeof attr
);
96 attr
.dlid
= ibp
->sm_lid
;
97 attr
.port_num
= ppd_from_ibp(ibp
)->port
;
98 ah
= ib_create_ah(ibp
->qp0
->ibqp
.pd
, &attr
);
103 ibp
->sm_ah
= to_iah(ah
);
109 send_buf
->ah
= &ibp
->sm_ah
->ibah
;
112 spin_unlock_irqrestore(&ibp
->lock
, flags
);
115 ret
= ib_post_send_mad(send_buf
, NULL
);
118 timeout
= (4096 * (1UL << ibp
->subnet_timeout
)) / 1000;
119 ibp
->trap_timeout
= jiffies
+ usecs_to_jiffies(timeout
);
121 ib_free_send_mad(send_buf
);
122 ibp
->trap_timeout
= 0;
127 * Send a bad [PQ]_Key trap (ch. 14.3.8).
129 void qib_bad_pqkey(struct qib_ibport
*ibp
, __be16 trap_num
, u32 key
, u32 sl
,
130 u32 qp1
, u32 qp2
, __be16 lid1
, __be16 lid2
)
132 struct ib_mad_notice_attr data
;
134 if (trap_num
== IB_NOTICE_TRAP_BAD_PKEY
)
135 ibp
->pkey_violations
++;
137 ibp
->qkey_violations
++;
140 /* Send violation trap */
141 data
.generic_type
= IB_NOTICE_TYPE_SECURITY
;
142 data
.prod_type_msb
= 0;
143 data
.prod_type_lsb
= IB_NOTICE_PROD_CA
;
144 data
.trap_num
= trap_num
;
145 data
.issuer_lid
= cpu_to_be16(ppd_from_ibp(ibp
)->lid
);
146 data
.toggle_count
= 0;
147 memset(&data
.details
, 0, sizeof data
.details
);
148 data
.details
.ntc_257_258
.lid1
= lid1
;
149 data
.details
.ntc_257_258
.lid2
= lid2
;
150 data
.details
.ntc_257_258
.key
= cpu_to_be32(key
);
151 data
.details
.ntc_257_258
.sl_qp1
= cpu_to_be32((sl
<< 28) | qp1
);
152 data
.details
.ntc_257_258
.qp2
= cpu_to_be32(qp2
);
154 qib_send_trap(ibp
, &data
, sizeof data
);
158 * Send a bad M_Key trap (ch. 14.3.9).
160 static void qib_bad_mkey(struct qib_ibport
*ibp
, struct ib_smp
*smp
)
162 struct ib_mad_notice_attr data
;
164 /* Send violation trap */
165 data
.generic_type
= IB_NOTICE_TYPE_SECURITY
;
166 data
.prod_type_msb
= 0;
167 data
.prod_type_lsb
= IB_NOTICE_PROD_CA
;
168 data
.trap_num
= IB_NOTICE_TRAP_BAD_MKEY
;
169 data
.issuer_lid
= cpu_to_be16(ppd_from_ibp(ibp
)->lid
);
170 data
.toggle_count
= 0;
171 memset(&data
.details
, 0, sizeof data
.details
);
172 data
.details
.ntc_256
.lid
= data
.issuer_lid
;
173 data
.details
.ntc_256
.method
= smp
->method
;
174 data
.details
.ntc_256
.attr_id
= smp
->attr_id
;
175 data
.details
.ntc_256
.attr_mod
= smp
->attr_mod
;
176 data
.details
.ntc_256
.mkey
= smp
->mkey
;
177 if (smp
->mgmt_class
== IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE
) {
180 data
.details
.ntc_256
.dr_slid
= smp
->dr_slid
;
181 data
.details
.ntc_256
.dr_trunc_hop
= IB_NOTICE_TRAP_DR_NOTICE
;
182 hop_cnt
= smp
->hop_cnt
;
183 if (hop_cnt
> ARRAY_SIZE(data
.details
.ntc_256
.dr_rtn_path
)) {
184 data
.details
.ntc_256
.dr_trunc_hop
|=
185 IB_NOTICE_TRAP_DR_TRUNC
;
186 hop_cnt
= ARRAY_SIZE(data
.details
.ntc_256
.dr_rtn_path
);
188 data
.details
.ntc_256
.dr_trunc_hop
|= hop_cnt
;
189 memcpy(data
.details
.ntc_256
.dr_rtn_path
, smp
->return_path
,
193 qib_send_trap(ibp
, &data
, sizeof data
);
197 * Send a Port Capability Mask Changed trap (ch. 14.3.11).
199 void qib_cap_mask_chg(struct qib_ibport
*ibp
)
201 struct ib_mad_notice_attr data
;
203 data
.generic_type
= IB_NOTICE_TYPE_INFO
;
204 data
.prod_type_msb
= 0;
205 data
.prod_type_lsb
= IB_NOTICE_PROD_CA
;
206 data
.trap_num
= IB_NOTICE_TRAP_CAP_MASK_CHG
;
207 data
.issuer_lid
= cpu_to_be16(ppd_from_ibp(ibp
)->lid
);
208 data
.toggle_count
= 0;
209 memset(&data
.details
, 0, sizeof data
.details
);
210 data
.details
.ntc_144
.lid
= data
.issuer_lid
;
211 data
.details
.ntc_144
.new_cap_mask
= cpu_to_be32(ibp
->port_cap_flags
);
213 qib_send_trap(ibp
, &data
, sizeof data
);
217 * Send a System Image GUID Changed trap (ch. 14.3.12).
219 void qib_sys_guid_chg(struct qib_ibport
*ibp
)
221 struct ib_mad_notice_attr data
;
223 data
.generic_type
= IB_NOTICE_TYPE_INFO
;
224 data
.prod_type_msb
= 0;
225 data
.prod_type_lsb
= IB_NOTICE_PROD_CA
;
226 data
.trap_num
= IB_NOTICE_TRAP_SYS_GUID_CHG
;
227 data
.issuer_lid
= cpu_to_be16(ppd_from_ibp(ibp
)->lid
);
228 data
.toggle_count
= 0;
229 memset(&data
.details
, 0, sizeof data
.details
);
230 data
.details
.ntc_145
.lid
= data
.issuer_lid
;
231 data
.details
.ntc_145
.new_sys_guid
= ib_qib_sys_image_guid
;
233 qib_send_trap(ibp
, &data
, sizeof data
);
237 * Send a Node Description Changed trap (ch. 14.3.13).
239 void qib_node_desc_chg(struct qib_ibport
*ibp
)
241 struct ib_mad_notice_attr data
;
243 data
.generic_type
= IB_NOTICE_TYPE_INFO
;
244 data
.prod_type_msb
= 0;
245 data
.prod_type_lsb
= IB_NOTICE_PROD_CA
;
246 data
.trap_num
= IB_NOTICE_TRAP_CAP_MASK_CHG
;
247 data
.issuer_lid
= cpu_to_be16(ppd_from_ibp(ibp
)->lid
);
248 data
.toggle_count
= 0;
249 memset(&data
.details
, 0, sizeof data
.details
);
250 data
.details
.ntc_144
.lid
= data
.issuer_lid
;
251 data
.details
.ntc_144
.local_changes
= 1;
252 data
.details
.ntc_144
.change_flags
= IB_NOTICE_TRAP_NODE_DESC_CHG
;
254 qib_send_trap(ibp
, &data
, sizeof data
);
257 static int subn_get_nodedescription(struct ib_smp
*smp
,
258 struct ib_device
*ibdev
)
261 smp
->status
|= IB_SMP_INVALID_FIELD
;
263 memcpy(smp
->data
, ibdev
->node_desc
, sizeof(smp
->data
));
268 static int subn_get_nodeinfo(struct ib_smp
*smp
, struct ib_device
*ibdev
,
271 struct ib_node_info
*nip
= (struct ib_node_info
*)&smp
->data
;
272 struct qib_devdata
*dd
= dd_from_ibdev(ibdev
);
273 u32 vendor
, majrev
, minrev
;
274 unsigned pidx
= port
- 1; /* IB number port from 1, hdw from 0 */
276 /* GUID 0 is illegal */
277 if (smp
->attr_mod
|| pidx
>= dd
->num_pports
||
278 dd
->pport
[pidx
].guid
== 0)
279 smp
->status
|= IB_SMP_INVALID_FIELD
;
281 nip
->port_guid
= dd
->pport
[pidx
].guid
;
283 nip
->base_version
= 1;
284 nip
->class_version
= 1;
285 nip
->node_type
= 1; /* channel adapter */
286 nip
->num_ports
= ibdev
->phys_port_cnt
;
287 /* This is already in network order */
288 nip
->sys_guid
= ib_qib_sys_image_guid
;
289 nip
->node_guid
= dd
->pport
->guid
; /* Use first-port GUID as node */
290 nip
->partition_cap
= cpu_to_be16(qib_get_npkeys(dd
));
291 nip
->device_id
= cpu_to_be16(dd
->deviceid
);
294 nip
->revision
= cpu_to_be32((majrev
<< 16) | minrev
);
295 nip
->local_port_num
= port
;
296 vendor
= dd
->vendorid
;
297 nip
->vendor_id
[0] = QIB_SRC_OUI_1
;
298 nip
->vendor_id
[1] = QIB_SRC_OUI_2
;
299 nip
->vendor_id
[2] = QIB_SRC_OUI_3
;
304 static int subn_get_guidinfo(struct ib_smp
*smp
, struct ib_device
*ibdev
,
307 struct qib_devdata
*dd
= dd_from_ibdev(ibdev
);
308 u32 startgx
= 8 * be32_to_cpu(smp
->attr_mod
);
309 __be64
*p
= (__be64
*) smp
->data
;
310 unsigned pidx
= port
- 1; /* IB number port from 1, hdw from 0 */
312 /* 32 blocks of 8 64-bit GUIDs per block */
314 memset(smp
->data
, 0, sizeof(smp
->data
));
316 if (startgx
== 0 && pidx
< dd
->num_pports
) {
317 struct qib_pportdata
*ppd
= dd
->pport
+ pidx
;
318 struct qib_ibport
*ibp
= &ppd
->ibport_data
;
319 __be64 g
= ppd
->guid
;
322 /* GUID 0 is illegal */
324 smp
->status
|= IB_SMP_INVALID_FIELD
;
326 /* The first is a copy of the read-only HW GUID. */
328 for (i
= 1; i
< QIB_GUIDS_PER_PORT
; i
++)
329 p
[i
] = ibp
->guids
[i
- 1];
332 smp
->status
|= IB_SMP_INVALID_FIELD
;
337 static void set_link_width_enabled(struct qib_pportdata
*ppd
, u32 w
)
339 (void) ppd
->dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_LWID_ENB
, w
);
342 static void set_link_speed_enabled(struct qib_pportdata
*ppd
, u32 s
)
344 (void) ppd
->dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_SPD_ENB
, s
);
347 static int get_overrunthreshold(struct qib_pportdata
*ppd
)
349 return ppd
->dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_OVERRUN_THRESH
);
353 * set_overrunthreshold - set the overrun threshold
354 * @ppd: the physical port data
355 * @n: the new threshold
357 * Note that this will only take effect when the link state changes.
359 static int set_overrunthreshold(struct qib_pportdata
*ppd
, unsigned n
)
361 (void) ppd
->dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_OVERRUN_THRESH
,
366 static int get_phyerrthreshold(struct qib_pportdata
*ppd
)
368 return ppd
->dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_PHYERR_THRESH
);
372 * set_phyerrthreshold - set the physical error threshold
373 * @ppd: the physical port data
374 * @n: the new threshold
376 * Note that this will only take effect when the link state changes.
378 static int set_phyerrthreshold(struct qib_pportdata
*ppd
, unsigned n
)
380 (void) ppd
->dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_PHYERR_THRESH
,
386 * get_linkdowndefaultstate - get the default linkdown state
387 * @ppd: the physical port data
389 * Returns zero if the default is POLL, 1 if the default is SLEEP.
391 static int get_linkdowndefaultstate(struct qib_pportdata
*ppd
)
393 return ppd
->dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_LINKDEFAULT
) ==
394 IB_LINKINITCMD_SLEEP
;
397 static int check_mkey(struct qib_ibport
*ibp
, struct ib_smp
*smp
, int mad_flags
)
401 /* Is the mkey in the process of expiring? */
402 if (ibp
->mkey_lease_timeout
&&
403 time_after_eq(jiffies
, ibp
->mkey_lease_timeout
)) {
404 /* Clear timeout and mkey protection field. */
405 ibp
->mkey_lease_timeout
= 0;
409 /* M_Key checking depends on Portinfo:M_Key_protect_bits */
410 if ((mad_flags
& IB_MAD_IGNORE_MKEY
) == 0 && ibp
->mkey
!= 0 &&
411 ibp
->mkey
!= smp
->mkey
&&
412 (smp
->method
== IB_MGMT_METHOD_SET
||
413 smp
->method
== IB_MGMT_METHOD_TRAP_REPRESS
||
414 (smp
->method
== IB_MGMT_METHOD_GET
&& ibp
->mkeyprot
>= 2))) {
415 if (ibp
->mkey_violations
!= 0xFFFF)
416 ++ibp
->mkey_violations
;
417 if (!ibp
->mkey_lease_timeout
&& ibp
->mkey_lease_period
)
418 ibp
->mkey_lease_timeout
= jiffies
+
419 ibp
->mkey_lease_period
* HZ
;
420 /* Generate a trap notice. */
421 qib_bad_mkey(ibp
, smp
);
422 ret
= IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_CONSUMED
;
423 } else if (ibp
->mkey_lease_timeout
)
424 ibp
->mkey_lease_timeout
= 0;
429 static int subn_get_portinfo(struct ib_smp
*smp
, struct ib_device
*ibdev
,
432 struct qib_devdata
*dd
;
433 struct qib_pportdata
*ppd
;
434 struct qib_ibport
*ibp
;
435 struct ib_port_info
*pip
= (struct ib_port_info
*)smp
->data
;
440 u32 port_num
= be32_to_cpu(smp
->attr_mod
);
445 if (port_num
> ibdev
->phys_port_cnt
) {
446 smp
->status
|= IB_SMP_INVALID_FIELD
;
450 if (port_num
!= port
) {
451 ibp
= to_iport(ibdev
, port_num
);
452 ret
= check_mkey(ibp
, smp
, 0);
458 dd
= dd_from_ibdev(ibdev
);
459 /* IB numbers ports from 1, hdw from 0 */
460 ppd
= dd
->pport
+ (port_num
- 1);
461 ibp
= &ppd
->ibport_data
;
463 /* Clear all fields. Only set the non-zero fields. */
464 memset(smp
->data
, 0, sizeof(smp
->data
));
466 /* Only return the mkey if the protection field allows it. */
467 if (smp
->method
== IB_MGMT_METHOD_SET
|| ibp
->mkey
== smp
->mkey
||
469 pip
->mkey
= ibp
->mkey
;
470 pip
->gid_prefix
= ibp
->gid_prefix
;
472 pip
->lid
= lid
? cpu_to_be16(lid
) : IB_LID_PERMISSIVE
;
473 pip
->sm_lid
= cpu_to_be16(ibp
->sm_lid
);
474 pip
->cap_mask
= cpu_to_be32(ibp
->port_cap_flags
);
475 /* pip->diag_code; */
476 pip
->mkey_lease_period
= cpu_to_be16(ibp
->mkey_lease_period
);
477 pip
->local_port_num
= port
;
478 pip
->link_width_enabled
= ppd
->link_width_enabled
;
479 pip
->link_width_supported
= ppd
->link_width_supported
;
480 pip
->link_width_active
= ppd
->link_width_active
;
481 state
= dd
->f_iblink_state(ppd
->lastibcstat
);
482 pip
->linkspeed_portstate
= ppd
->link_speed_supported
<< 4 | state
;
484 pip
->portphysstate_linkdown
=
485 (dd
->f_ibphys_portstate(ppd
->lastibcstat
) << 4) |
486 (get_linkdowndefaultstate(ppd
) ? 1 : 2);
487 pip
->mkeyprot_resv_lmc
= (ibp
->mkeyprot
<< 6) | ppd
->lmc
;
488 pip
->linkspeedactive_enabled
= (ppd
->link_speed_active
<< 4) |
489 ppd
->link_speed_enabled
;
490 switch (ppd
->ibmtu
) {
491 default: /* something is wrong; fall through */
508 pip
->neighbormtu_mastersmsl
= (mtu
<< 4) | ibp
->sm_sl
;
509 pip
->vlcap_inittype
= ppd
->vls_supported
<< 4; /* InitType = 0 */
510 pip
->vl_high_limit
= ibp
->vl_high_limit
;
511 pip
->vl_arb_high_cap
=
512 dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_VL_HIGH_CAP
);
513 pip
->vl_arb_low_cap
=
514 dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_VL_LOW_CAP
);
515 /* InitTypeReply = 0 */
516 pip
->inittypereply_mtucap
= qib_ibmtu
? qib_ibmtu
: IB_MTU_4096
;
517 /* HCAs ignore VLStallCount and HOQLife */
518 /* pip->vlstallcnt_hoqlife; */
519 pip
->operationalvl_pei_peo_fpi_fpo
=
520 dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_OP_VLS
) << 4;
521 pip
->mkey_violations
= cpu_to_be16(ibp
->mkey_violations
);
522 /* P_KeyViolations are counted by hardware. */
523 pip
->pkey_violations
= cpu_to_be16(ibp
->pkey_violations
);
524 pip
->qkey_violations
= cpu_to_be16(ibp
->qkey_violations
);
525 /* Only the hardware GUID is supported for now */
526 pip
->guid_cap
= QIB_GUIDS_PER_PORT
;
527 pip
->clientrereg_resv_subnetto
= ibp
->subnet_timeout
;
528 /* 32.768 usec. response time (guessing) */
529 pip
->resv_resptimevalue
= 3;
530 pip
->localphyerrors_overrunerrors
=
531 (get_phyerrthreshold(ppd
) << 4) |
532 get_overrunthreshold(ppd
);
533 /* pip->max_credit_hint; */
534 if (ibp
->port_cap_flags
& IB_PORT_LINK_LATENCY_SUP
) {
537 v
= dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_LINKLATENCY
);
538 pip
->link_roundtrip_latency
[0] = v
>> 16;
539 pip
->link_roundtrip_latency
[1] = v
>> 8;
540 pip
->link_roundtrip_latency
[2] = v
;
550 * get_pkeys - return the PKEY table
551 * @dd: the qlogic_ib device
552 * @port: the IB port number
553 * @pkeys: the pkey table is placed here
555 static int get_pkeys(struct qib_devdata
*dd
, u8 port
, u16
*pkeys
)
557 struct qib_pportdata
*ppd
= dd
->pport
+ port
- 1;
559 * always a kernel context, no locking needed.
560 * If we get here with ppd setup, no need to check
563 struct qib_ctxtdata
*rcd
= dd
->rcd
[ppd
->hw_pidx
];
565 memcpy(pkeys
, rcd
->pkeys
, sizeof(rcd
->pkeys
));
570 static int subn_get_pkeytable(struct ib_smp
*smp
, struct ib_device
*ibdev
,
573 u32 startpx
= 32 * (be32_to_cpu(smp
->attr_mod
) & 0xffff);
574 u16
*p
= (u16
*) smp
->data
;
575 __be16
*q
= (__be16
*) smp
->data
;
577 /* 64 blocks of 32 16-bit P_Key entries */
579 memset(smp
->data
, 0, sizeof(smp
->data
));
581 struct qib_devdata
*dd
= dd_from_ibdev(ibdev
);
582 unsigned i
, n
= qib_get_npkeys(dd
);
584 get_pkeys(dd
, port
, p
);
586 for (i
= 0; i
< n
; i
++)
587 q
[i
] = cpu_to_be16(p
[i
]);
589 smp
->status
|= IB_SMP_INVALID_FIELD
;
594 static int subn_set_guidinfo(struct ib_smp
*smp
, struct ib_device
*ibdev
,
597 struct qib_devdata
*dd
= dd_from_ibdev(ibdev
);
598 u32 startgx
= 8 * be32_to_cpu(smp
->attr_mod
);
599 __be64
*p
= (__be64
*) smp
->data
;
600 unsigned pidx
= port
- 1; /* IB number port from 1, hdw from 0 */
602 /* 32 blocks of 8 64-bit GUIDs per block */
604 if (startgx
== 0 && pidx
< dd
->num_pports
) {
605 struct qib_pportdata
*ppd
= dd
->pport
+ pidx
;
606 struct qib_ibport
*ibp
= &ppd
->ibport_data
;
609 /* The first entry is read-only. */
610 for (i
= 1; i
< QIB_GUIDS_PER_PORT
; i
++)
611 ibp
->guids
[i
- 1] = p
[i
];
613 smp
->status
|= IB_SMP_INVALID_FIELD
;
615 /* The only GUID we support is the first read-only entry. */
616 return subn_get_guidinfo(smp
, ibdev
, port
);
620 * subn_set_portinfo - set port information
621 * @smp: the incoming SM packet
622 * @ibdev: the infiniband device
623 * @port: the port on the device
625 * Set Portinfo (see ch. 14.2.5.6).
627 static int subn_set_portinfo(struct ib_smp
*smp
, struct ib_device
*ibdev
,
630 struct ib_port_info
*pip
= (struct ib_port_info
*)smp
->data
;
631 struct ib_event event
;
632 struct qib_devdata
*dd
;
633 struct qib_pportdata
*ppd
;
634 struct qib_ibport
*ibp
;
635 char clientrereg
= 0;
645 u32 port_num
= be32_to_cpu(smp
->attr_mod
);
650 if (port_num
> ibdev
->phys_port_cnt
)
652 /* Port attributes can only be set on the receiving port */
653 if (port_num
!= port
)
657 dd
= dd_from_ibdev(ibdev
);
658 /* IB numbers ports from 1, hdw from 0 */
659 ppd
= dd
->pport
+ (port_num
- 1);
660 ibp
= &ppd
->ibport_data
;
661 event
.device
= ibdev
;
662 event
.element
.port_num
= port
;
664 ibp
->mkey
= pip
->mkey
;
665 ibp
->gid_prefix
= pip
->gid_prefix
;
666 ibp
->mkey_lease_period
= be16_to_cpu(pip
->mkey_lease_period
);
668 lid
= be16_to_cpu(pip
->lid
);
669 /* Must be a valid unicast LID address. */
670 if (lid
== 0 || lid
>= QIB_MULTICAST_LID_BASE
)
672 if (ppd
->lid
!= lid
|| ppd
->lmc
!= (pip
->mkeyprot_resv_lmc
& 7)) {
674 qib_set_uevent_bits(ppd
, _QIB_EVENT_LID_CHANGE_BIT
);
675 if (ppd
->lmc
!= (pip
->mkeyprot_resv_lmc
& 7))
676 qib_set_uevent_bits(ppd
, _QIB_EVENT_LMC_CHANGE_BIT
);
677 qib_set_lid(ppd
, lid
, pip
->mkeyprot_resv_lmc
& 7);
678 event
.event
= IB_EVENT_LID_CHANGE
;
679 ib_dispatch_event(&event
);
682 smlid
= be16_to_cpu(pip
->sm_lid
);
683 msl
= pip
->neighbormtu_mastersmsl
& 0xF;
684 /* Must be a valid unicast LID address. */
685 if (smlid
== 0 || smlid
>= QIB_MULTICAST_LID_BASE
)
687 if (smlid
!= ibp
->sm_lid
|| msl
!= ibp
->sm_sl
) {
688 spin_lock_irqsave(&ibp
->lock
, flags
);
690 if (smlid
!= ibp
->sm_lid
)
691 ibp
->sm_ah
->attr
.dlid
= smlid
;
692 if (msl
!= ibp
->sm_sl
)
693 ibp
->sm_ah
->attr
.sl
= msl
;
695 spin_unlock_irqrestore(&ibp
->lock
, flags
);
696 if (smlid
!= ibp
->sm_lid
)
698 if (msl
!= ibp
->sm_sl
)
700 event
.event
= IB_EVENT_SM_CHANGE
;
701 ib_dispatch_event(&event
);
704 /* Allow 1x or 4x to be set (see 14.2.6.6). */
705 lwe
= pip
->link_width_enabled
;
708 lwe
= ppd
->link_width_supported
;
709 else if (lwe
>= 16 || (lwe
& ~ppd
->link_width_supported
))
711 set_link_width_enabled(ppd
, lwe
);
714 lse
= pip
->linkspeedactive_enabled
& 0xF;
717 * The IB 1.2 spec. only allows link speed values
718 * 1, 3, 5, 7, 15. 1.2.1 extended to allow specific
722 lse
= ppd
->link_speed_supported
;
723 else if (lse
>= 8 || (lse
& ~ppd
->link_speed_supported
))
725 set_link_speed_enabled(ppd
, lse
);
728 /* Set link down default state. */
729 switch (pip
->portphysstate_linkdown
& 0xF) {
733 (void) dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_LINKDEFAULT
,
734 IB_LINKINITCMD_SLEEP
);
737 (void) dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_LINKDEFAULT
,
738 IB_LINKINITCMD_POLL
);
744 ibp
->mkeyprot
= pip
->mkeyprot_resv_lmc
>> 6;
745 ibp
->vl_high_limit
= pip
->vl_high_limit
;
746 (void) dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_VL_HIGH_LIMIT
,
749 mtu
= ib_mtu_enum_to_int((pip
->neighbormtu_mastersmsl
>> 4) & 0xF);
752 qib_set_mtu(ppd
, mtu
);
754 /* Set operational VLs */
755 vls
= (pip
->operationalvl_pei_peo_fpi_fpo
>> 4) & 0xF;
757 if (vls
> ppd
->vls_supported
)
759 (void) dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_OP_VLS
, vls
);
762 if (pip
->mkey_violations
== 0)
763 ibp
->mkey_violations
= 0;
765 if (pip
->pkey_violations
== 0)
766 ibp
->pkey_violations
= 0;
768 if (pip
->qkey_violations
== 0)
769 ibp
->qkey_violations
= 0;
771 ore
= pip
->localphyerrors_overrunerrors
;
772 if (set_phyerrthreshold(ppd
, (ore
>> 4) & 0xF))
775 if (set_overrunthreshold(ppd
, (ore
& 0xF)))
778 ibp
->subnet_timeout
= pip
->clientrereg_resv_subnetto
& 0x1F;
780 if (pip
->clientrereg_resv_subnetto
& 0x80) {
782 event
.event
= IB_EVENT_CLIENT_REREGISTER
;
783 ib_dispatch_event(&event
);
787 * Do the port state change now that the other link parameters
789 * Changing the port physical state only makes sense if the link
790 * is down or is being set to down.
792 state
= pip
->linkspeed_portstate
& 0xF;
793 lstate
= (pip
->portphysstate_linkdown
>> 4) & 0xF;
794 if (lstate
&& !(state
== IB_PORT_DOWN
|| state
== IB_PORT_NOP
))
798 * Only state changes of DOWN, ARM, and ACTIVE are valid
799 * and must be in the correct state to take effect (see 7.2.6).
808 lstate
= QIB_IB_LINKDOWN_ONLY
;
809 else if (lstate
== 1)
810 lstate
= QIB_IB_LINKDOWN_SLEEP
;
811 else if (lstate
== 2)
812 lstate
= QIB_IB_LINKDOWN
;
813 else if (lstate
== 3)
814 lstate
= QIB_IB_LINKDOWN_DISABLE
;
817 spin_lock_irqsave(&ppd
->lflags_lock
, flags
);
818 ppd
->lflags
&= ~QIBL_LINKV
;
819 spin_unlock_irqrestore(&ppd
->lflags_lock
, flags
);
820 qib_set_linkstate(ppd
, lstate
);
822 * Don't send a reply if the response would be sent
823 * through the disabled port.
825 if (lstate
== QIB_IB_LINKDOWN_DISABLE
&& smp
->hop_cnt
) {
826 ret
= IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_CONSUMED
;
829 qib_wait_linkstate(ppd
, QIBL_LINKV
, 10);
832 qib_set_linkstate(ppd
, QIB_IB_LINKARM
);
835 qib_set_linkstate(ppd
, QIB_IB_LINKACTIVE
);
841 ret
= subn_get_portinfo(smp
, ibdev
, port
);
844 pip
->clientrereg_resv_subnetto
|= 0x80;
849 smp
->status
|= IB_SMP_INVALID_FIELD
;
851 ret
= subn_get_portinfo(smp
, ibdev
, port
);
857 * rm_pkey - decrecment the reference count for the given PKEY
858 * @dd: the qlogic_ib device
859 * @key: the PKEY index
861 * Return true if this was the last reference and the hardware table entry
862 * needs to be changed.
864 static int rm_pkey(struct qib_pportdata
*ppd
, u16 key
)
869 for (i
= 0; i
< ARRAY_SIZE(ppd
->pkeys
); i
++) {
870 if (ppd
->pkeys
[i
] != key
)
872 if (atomic_dec_and_test(&ppd
->pkeyrefs
[i
])) {
887 * add_pkey - add the given PKEY to the hardware table
888 * @dd: the qlogic_ib device
891 * Return an error code if unable to add the entry, zero if no change,
892 * or 1 if the hardware PKEY register needs to be updated.
894 static int add_pkey(struct qib_pportdata
*ppd
, u16 key
)
897 u16 lkey
= key
& 0x7FFF;
901 if (lkey
== 0x7FFF) {
906 /* Look for an empty slot or a matching PKEY. */
907 for (i
= 0; i
< ARRAY_SIZE(ppd
->pkeys
); i
++) {
908 if (!ppd
->pkeys
[i
]) {
912 /* If it matches exactly, try to increment the ref count */
913 if (ppd
->pkeys
[i
] == key
) {
914 if (atomic_inc_return(&ppd
->pkeyrefs
[i
]) > 1) {
918 /* Lost the race. Look for an empty slot below. */
919 atomic_dec(&ppd
->pkeyrefs
[i
]);
923 * It makes no sense to have both the limited and unlimited
924 * PKEY set at the same time since the unlimited one will
925 * disable the limited one.
927 if ((ppd
->pkeys
[i
] & 0x7FFF) == lkey
) {
936 for (i
= 0; i
< ARRAY_SIZE(ppd
->pkeys
); i
++) {
937 if (!ppd
->pkeys
[i
] &&
938 atomic_inc_return(&ppd
->pkeyrefs
[i
]) == 1) {
939 /* for qibstats, etc. */
952 * set_pkeys - set the PKEY table for ctxt 0
953 * @dd: the qlogic_ib device
954 * @port: the IB port number
955 * @pkeys: the PKEY table
957 static int set_pkeys(struct qib_devdata
*dd
, u8 port
, u16
*pkeys
)
959 struct qib_pportdata
*ppd
;
960 struct qib_ctxtdata
*rcd
;
965 * IB port one/two always maps to context zero/one,
966 * always a kernel context, no locking needed
967 * If we get here with ppd setup, no need to check
970 ppd
= dd
->pport
+ (port
- 1);
971 rcd
= dd
->rcd
[ppd
->hw_pidx
];
973 for (i
= 0; i
< ARRAY_SIZE(rcd
->pkeys
); i
++) {
975 u16 okey
= rcd
->pkeys
[i
];
980 * The value of this PKEY table entry is changing.
981 * Remove the old entry in the hardware's array of PKEYs.
984 changed
|= rm_pkey(ppd
, okey
);
986 int ret
= add_pkey(ppd
, key
);
996 struct ib_event event
;
998 (void) dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_PKEYS
, 0);
1000 event
.event
= IB_EVENT_PKEY_CHANGE
;
1001 event
.device
= &dd
->verbs_dev
.ibdev
;
1002 event
.element
.port_num
= 1;
1003 ib_dispatch_event(&event
);
1008 static int subn_set_pkeytable(struct ib_smp
*smp
, struct ib_device
*ibdev
,
1011 u32 startpx
= 32 * (be32_to_cpu(smp
->attr_mod
) & 0xffff);
1012 __be16
*p
= (__be16
*) smp
->data
;
1013 u16
*q
= (u16
*) smp
->data
;
1014 struct qib_devdata
*dd
= dd_from_ibdev(ibdev
);
1015 unsigned i
, n
= qib_get_npkeys(dd
);
1017 for (i
= 0; i
< n
; i
++)
1018 q
[i
] = be16_to_cpu(p
[i
]);
1020 if (startpx
!= 0 || set_pkeys(dd
, port
, q
) != 0)
1021 smp
->status
|= IB_SMP_INVALID_FIELD
;
1023 return subn_get_pkeytable(smp
, ibdev
, port
);
1026 static int subn_get_sl_to_vl(struct ib_smp
*smp
, struct ib_device
*ibdev
,
1029 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1030 u8
*p
= (u8
*) smp
->data
;
1033 memset(smp
->data
, 0, sizeof(smp
->data
));
1035 if (!(ibp
->port_cap_flags
& IB_PORT_SL_MAP_SUP
))
1036 smp
->status
|= IB_SMP_UNSUP_METHOD
;
1038 for (i
= 0; i
< ARRAY_SIZE(ibp
->sl_to_vl
); i
+= 2)
1039 *p
++ = (ibp
->sl_to_vl
[i
] << 4) | ibp
->sl_to_vl
[i
+ 1];
1044 static int subn_set_sl_to_vl(struct ib_smp
*smp
, struct ib_device
*ibdev
,
1047 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1048 u8
*p
= (u8
*) smp
->data
;
1051 if (!(ibp
->port_cap_flags
& IB_PORT_SL_MAP_SUP
)) {
1052 smp
->status
|= IB_SMP_UNSUP_METHOD
;
1056 for (i
= 0; i
< ARRAY_SIZE(ibp
->sl_to_vl
); i
+= 2, p
++) {
1057 ibp
->sl_to_vl
[i
] = *p
>> 4;
1058 ibp
->sl_to_vl
[i
+ 1] = *p
& 0xF;
1060 qib_set_uevent_bits(ppd_from_ibp(to_iport(ibdev
, port
)),
1061 _QIB_EVENT_SL2VL_CHANGE_BIT
);
1063 return subn_get_sl_to_vl(smp
, ibdev
, port
);
1066 static int subn_get_vl_arb(struct ib_smp
*smp
, struct ib_device
*ibdev
,
1069 unsigned which
= be32_to_cpu(smp
->attr_mod
) >> 16;
1070 struct qib_pportdata
*ppd
= ppd_from_ibp(to_iport(ibdev
, port
));
1072 memset(smp
->data
, 0, sizeof(smp
->data
));
1074 if (ppd
->vls_supported
== IB_VL_VL0
)
1075 smp
->status
|= IB_SMP_UNSUP_METHOD
;
1076 else if (which
== IB_VLARB_LOWPRI_0_31
)
1077 (void) ppd
->dd
->f_get_ib_table(ppd
, QIB_IB_TBL_VL_LOW_ARB
,
1079 else if (which
== IB_VLARB_HIGHPRI_0_31
)
1080 (void) ppd
->dd
->f_get_ib_table(ppd
, QIB_IB_TBL_VL_HIGH_ARB
,
1083 smp
->status
|= IB_SMP_INVALID_FIELD
;
1088 static int subn_set_vl_arb(struct ib_smp
*smp
, struct ib_device
*ibdev
,
1091 unsigned which
= be32_to_cpu(smp
->attr_mod
) >> 16;
1092 struct qib_pportdata
*ppd
= ppd_from_ibp(to_iport(ibdev
, port
));
1094 if (ppd
->vls_supported
== IB_VL_VL0
)
1095 smp
->status
|= IB_SMP_UNSUP_METHOD
;
1096 else if (which
== IB_VLARB_LOWPRI_0_31
)
1097 (void) ppd
->dd
->f_set_ib_table(ppd
, QIB_IB_TBL_VL_LOW_ARB
,
1099 else if (which
== IB_VLARB_HIGHPRI_0_31
)
1100 (void) ppd
->dd
->f_set_ib_table(ppd
, QIB_IB_TBL_VL_HIGH_ARB
,
1103 smp
->status
|= IB_SMP_INVALID_FIELD
;
1105 return subn_get_vl_arb(smp
, ibdev
, port
);
1108 static int subn_trap_repress(struct ib_smp
*smp
, struct ib_device
*ibdev
,
1112 * For now, we only send the trap once so no need to process this.
1114 * o14-3.a4 The SMA shall not send any message in response to a valid
1115 * SubnTrapRepress() message.
1117 return IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_CONSUMED
;
1120 static int pma_get_classportinfo(struct ib_perf
*pmp
,
1121 struct ib_device
*ibdev
)
1123 struct ib_pma_classportinfo
*p
=
1124 (struct ib_pma_classportinfo
*)pmp
->data
;
1125 struct qib_devdata
*dd
= dd_from_ibdev(ibdev
);
1127 memset(pmp
->data
, 0, sizeof(pmp
->data
));
1129 if (pmp
->attr_mod
!= 0)
1130 pmp
->status
|= IB_SMP_INVALID_FIELD
;
1132 /* Note that AllPortSelect is not valid */
1133 p
->base_version
= 1;
1134 p
->class_version
= 1;
1135 p
->cap_mask
= IB_PMA_CLASS_CAP_EXT_WIDTH
;
1137 * Set the most significant bit of CM2 to indicate support for
1138 * congestion statistics
1140 p
->reserved
[0] = dd
->psxmitwait_supported
<< 7;
1142 * Expected response time is 4.096 usec. * 2^18 == 1.073741824 sec.
1144 p
->resp_time_value
= 18;
1146 return reply((struct ib_smp
*) pmp
);
1149 static int pma_get_portsamplescontrol(struct ib_perf
*pmp
,
1150 struct ib_device
*ibdev
, u8 port
)
1152 struct ib_pma_portsamplescontrol
*p
=
1153 (struct ib_pma_portsamplescontrol
*)pmp
->data
;
1154 struct qib_ibdev
*dev
= to_idev(ibdev
);
1155 struct qib_devdata
*dd
= dd_from_dev(dev
);
1156 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1157 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1158 unsigned long flags
;
1159 u8 port_select
= p
->port_select
;
1161 memset(pmp
->data
, 0, sizeof(pmp
->data
));
1163 p
->port_select
= port_select
;
1164 if (pmp
->attr_mod
!= 0 || port_select
!= port
) {
1165 pmp
->status
|= IB_SMP_INVALID_FIELD
;
1168 spin_lock_irqsave(&ibp
->lock
, flags
);
1169 p
->tick
= dd
->f_get_ib_cfg(ppd
, QIB_IB_CFG_PMA_TICKS
);
1170 p
->sample_status
= dd
->f_portcntr(ppd
, QIBPORTCNTR_PSSTAT
);
1171 p
->counter_width
= 4; /* 32 bit counters */
1172 p
->counter_mask0_9
= COUNTER_MASK0_9
;
1173 p
->sample_start
= cpu_to_be32(ibp
->pma_sample_start
);
1174 p
->sample_interval
= cpu_to_be32(ibp
->pma_sample_interval
);
1175 p
->tag
= cpu_to_be16(ibp
->pma_tag
);
1176 p
->counter_select
[0] = ibp
->pma_counter_select
[0];
1177 p
->counter_select
[1] = ibp
->pma_counter_select
[1];
1178 p
->counter_select
[2] = ibp
->pma_counter_select
[2];
1179 p
->counter_select
[3] = ibp
->pma_counter_select
[3];
1180 p
->counter_select
[4] = ibp
->pma_counter_select
[4];
1181 spin_unlock_irqrestore(&ibp
->lock
, flags
);
1184 return reply((struct ib_smp
*) pmp
);
1187 static int pma_set_portsamplescontrol(struct ib_perf
*pmp
,
1188 struct ib_device
*ibdev
, u8 port
)
1190 struct ib_pma_portsamplescontrol
*p
=
1191 (struct ib_pma_portsamplescontrol
*)pmp
->data
;
1192 struct qib_ibdev
*dev
= to_idev(ibdev
);
1193 struct qib_devdata
*dd
= dd_from_dev(dev
);
1194 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1195 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1196 unsigned long flags
;
1197 u8 status
, xmit_flags
;
1200 if (pmp
->attr_mod
!= 0 || p
->port_select
!= port
) {
1201 pmp
->status
|= IB_SMP_INVALID_FIELD
;
1202 ret
= reply((struct ib_smp
*) pmp
);
1206 spin_lock_irqsave(&ibp
->lock
, flags
);
1208 /* Port Sampling code owns the PS* HW counters */
1209 xmit_flags
= ppd
->cong_stats
.flags
;
1210 ppd
->cong_stats
.flags
= IB_PMA_CONG_HW_CONTROL_SAMPLE
;
1211 status
= dd
->f_portcntr(ppd
, QIBPORTCNTR_PSSTAT
);
1212 if (status
== IB_PMA_SAMPLE_STATUS_DONE
||
1213 (status
== IB_PMA_SAMPLE_STATUS_RUNNING
&&
1214 xmit_flags
== IB_PMA_CONG_HW_CONTROL_TIMER
)) {
1215 ibp
->pma_sample_start
= be32_to_cpu(p
->sample_start
);
1216 ibp
->pma_sample_interval
= be32_to_cpu(p
->sample_interval
);
1217 ibp
->pma_tag
= be16_to_cpu(p
->tag
);
1218 ibp
->pma_counter_select
[0] = p
->counter_select
[0];
1219 ibp
->pma_counter_select
[1] = p
->counter_select
[1];
1220 ibp
->pma_counter_select
[2] = p
->counter_select
[2];
1221 ibp
->pma_counter_select
[3] = p
->counter_select
[3];
1222 ibp
->pma_counter_select
[4] = p
->counter_select
[4];
1223 dd
->f_set_cntr_sample(ppd
, ibp
->pma_sample_interval
,
1224 ibp
->pma_sample_start
);
1226 spin_unlock_irqrestore(&ibp
->lock
, flags
);
1228 ret
= pma_get_portsamplescontrol(pmp
, ibdev
, port
);
1234 static u64
get_counter(struct qib_ibport
*ibp
, struct qib_pportdata
*ppd
,
1240 case IB_PMA_PORT_XMIT_DATA
:
1241 ret
= ppd
->dd
->f_portcntr(ppd
, QIBPORTCNTR_PSXMITDATA
);
1243 case IB_PMA_PORT_RCV_DATA
:
1244 ret
= ppd
->dd
->f_portcntr(ppd
, QIBPORTCNTR_PSRCVDATA
);
1246 case IB_PMA_PORT_XMIT_PKTS
:
1247 ret
= ppd
->dd
->f_portcntr(ppd
, QIBPORTCNTR_PSXMITPKTS
);
1249 case IB_PMA_PORT_RCV_PKTS
:
1250 ret
= ppd
->dd
->f_portcntr(ppd
, QIBPORTCNTR_PSRCVPKTS
);
1252 case IB_PMA_PORT_XMIT_WAIT
:
1253 ret
= ppd
->dd
->f_portcntr(ppd
, QIBPORTCNTR_PSXMITWAIT
);
1262 /* This function assumes that the xmit_wait lock is already held */
1263 static u64
xmit_wait_get_value_delta(struct qib_pportdata
*ppd
)
1267 delta
= get_counter(&ppd
->ibport_data
, ppd
,
1268 IB_PMA_PORT_XMIT_WAIT
);
1269 return ppd
->cong_stats
.counter
+ delta
;
1272 static void cache_hw_sample_counters(struct qib_pportdata
*ppd
)
1274 struct qib_ibport
*ibp
= &ppd
->ibport_data
;
1276 ppd
->cong_stats
.counter_cache
.psxmitdata
=
1277 get_counter(ibp
, ppd
, IB_PMA_PORT_XMIT_DATA
);
1278 ppd
->cong_stats
.counter_cache
.psrcvdata
=
1279 get_counter(ibp
, ppd
, IB_PMA_PORT_RCV_DATA
);
1280 ppd
->cong_stats
.counter_cache
.psxmitpkts
=
1281 get_counter(ibp
, ppd
, IB_PMA_PORT_XMIT_PKTS
);
1282 ppd
->cong_stats
.counter_cache
.psrcvpkts
=
1283 get_counter(ibp
, ppd
, IB_PMA_PORT_RCV_PKTS
);
1284 ppd
->cong_stats
.counter_cache
.psxmitwait
=
1285 get_counter(ibp
, ppd
, IB_PMA_PORT_XMIT_WAIT
);
1288 static u64
get_cache_hw_sample_counters(struct qib_pportdata
*ppd
,
1294 case IB_PMA_PORT_XMIT_DATA
:
1295 ret
= ppd
->cong_stats
.counter_cache
.psxmitdata
;
1297 case IB_PMA_PORT_RCV_DATA
:
1298 ret
= ppd
->cong_stats
.counter_cache
.psrcvdata
;
1300 case IB_PMA_PORT_XMIT_PKTS
:
1301 ret
= ppd
->cong_stats
.counter_cache
.psxmitpkts
;
1303 case IB_PMA_PORT_RCV_PKTS
:
1304 ret
= ppd
->cong_stats
.counter_cache
.psrcvpkts
;
1306 case IB_PMA_PORT_XMIT_WAIT
:
1307 ret
= ppd
->cong_stats
.counter_cache
.psxmitwait
;
1316 static int pma_get_portsamplesresult(struct ib_perf
*pmp
,
1317 struct ib_device
*ibdev
, u8 port
)
1319 struct ib_pma_portsamplesresult
*p
=
1320 (struct ib_pma_portsamplesresult
*)pmp
->data
;
1321 struct qib_ibdev
*dev
= to_idev(ibdev
);
1322 struct qib_devdata
*dd
= dd_from_dev(dev
);
1323 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1324 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1325 unsigned long flags
;
1329 memset(pmp
->data
, 0, sizeof(pmp
->data
));
1330 spin_lock_irqsave(&ibp
->lock
, flags
);
1331 p
->tag
= cpu_to_be16(ibp
->pma_tag
);
1332 if (ppd
->cong_stats
.flags
== IB_PMA_CONG_HW_CONTROL_TIMER
)
1333 p
->sample_status
= IB_PMA_SAMPLE_STATUS_DONE
;
1335 status
= dd
->f_portcntr(ppd
, QIBPORTCNTR_PSSTAT
);
1336 p
->sample_status
= cpu_to_be16(status
);
1337 if (status
== IB_PMA_SAMPLE_STATUS_DONE
) {
1338 cache_hw_sample_counters(ppd
);
1339 ppd
->cong_stats
.counter
=
1340 xmit_wait_get_value_delta(ppd
);
1341 dd
->f_set_cntr_sample(ppd
,
1342 QIB_CONG_TIMER_PSINTERVAL
, 0);
1343 ppd
->cong_stats
.flags
= IB_PMA_CONG_HW_CONTROL_TIMER
;
1346 for (i
= 0; i
< ARRAY_SIZE(ibp
->pma_counter_select
); i
++)
1347 p
->counter
[i
] = cpu_to_be32(
1348 get_cache_hw_sample_counters(
1349 ppd
, ibp
->pma_counter_select
[i
]));
1350 spin_unlock_irqrestore(&ibp
->lock
, flags
);
1352 return reply((struct ib_smp
*) pmp
);
1355 static int pma_get_portsamplesresult_ext(struct ib_perf
*pmp
,
1356 struct ib_device
*ibdev
, u8 port
)
1358 struct ib_pma_portsamplesresult_ext
*p
=
1359 (struct ib_pma_portsamplesresult_ext
*)pmp
->data
;
1360 struct qib_ibdev
*dev
= to_idev(ibdev
);
1361 struct qib_devdata
*dd
= dd_from_dev(dev
);
1362 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1363 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1364 unsigned long flags
;
1368 /* Port Sampling code owns the PS* HW counters */
1369 memset(pmp
->data
, 0, sizeof(pmp
->data
));
1370 spin_lock_irqsave(&ibp
->lock
, flags
);
1371 p
->tag
= cpu_to_be16(ibp
->pma_tag
);
1372 if (ppd
->cong_stats
.flags
== IB_PMA_CONG_HW_CONTROL_TIMER
)
1373 p
->sample_status
= IB_PMA_SAMPLE_STATUS_DONE
;
1375 status
= dd
->f_portcntr(ppd
, QIBPORTCNTR_PSSTAT
);
1376 p
->sample_status
= cpu_to_be16(status
);
1378 p
->extended_width
= cpu_to_be32(0x80000000);
1379 if (status
== IB_PMA_SAMPLE_STATUS_DONE
) {
1380 cache_hw_sample_counters(ppd
);
1381 ppd
->cong_stats
.counter
=
1382 xmit_wait_get_value_delta(ppd
);
1383 dd
->f_set_cntr_sample(ppd
,
1384 QIB_CONG_TIMER_PSINTERVAL
, 0);
1385 ppd
->cong_stats
.flags
= IB_PMA_CONG_HW_CONTROL_TIMER
;
1388 for (i
= 0; i
< ARRAY_SIZE(ibp
->pma_counter_select
); i
++)
1389 p
->counter
[i
] = cpu_to_be64(
1390 get_cache_hw_sample_counters(
1391 ppd
, ibp
->pma_counter_select
[i
]));
1392 spin_unlock_irqrestore(&ibp
->lock
, flags
);
1394 return reply((struct ib_smp
*) pmp
);
1397 static int pma_get_portcounters(struct ib_perf
*pmp
,
1398 struct ib_device
*ibdev
, u8 port
)
1400 struct ib_pma_portcounters
*p
= (struct ib_pma_portcounters
*)
1402 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1403 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1404 struct qib_verbs_counters cntrs
;
1405 u8 port_select
= p
->port_select
;
1407 qib_get_counters(ppd
, &cntrs
);
1409 /* Adjust counters for any resets done. */
1410 cntrs
.symbol_error_counter
-= ibp
->z_symbol_error_counter
;
1411 cntrs
.link_error_recovery_counter
-=
1412 ibp
->z_link_error_recovery_counter
;
1413 cntrs
.link_downed_counter
-= ibp
->z_link_downed_counter
;
1414 cntrs
.port_rcv_errors
-= ibp
->z_port_rcv_errors
;
1415 cntrs
.port_rcv_remphys_errors
-= ibp
->z_port_rcv_remphys_errors
;
1416 cntrs
.port_xmit_discards
-= ibp
->z_port_xmit_discards
;
1417 cntrs
.port_xmit_data
-= ibp
->z_port_xmit_data
;
1418 cntrs
.port_rcv_data
-= ibp
->z_port_rcv_data
;
1419 cntrs
.port_xmit_packets
-= ibp
->z_port_xmit_packets
;
1420 cntrs
.port_rcv_packets
-= ibp
->z_port_rcv_packets
;
1421 cntrs
.local_link_integrity_errors
-=
1422 ibp
->z_local_link_integrity_errors
;
1423 cntrs
.excessive_buffer_overrun_errors
-=
1424 ibp
->z_excessive_buffer_overrun_errors
;
1425 cntrs
.vl15_dropped
-= ibp
->z_vl15_dropped
;
1426 cntrs
.vl15_dropped
+= ibp
->n_vl15_dropped
;
1428 memset(pmp
->data
, 0, sizeof(pmp
->data
));
1430 p
->port_select
= port_select
;
1431 if (pmp
->attr_mod
!= 0 || port_select
!= port
)
1432 pmp
->status
|= IB_SMP_INVALID_FIELD
;
1434 if (cntrs
.symbol_error_counter
> 0xFFFFUL
)
1435 p
->symbol_error_counter
= cpu_to_be16(0xFFFF);
1437 p
->symbol_error_counter
=
1438 cpu_to_be16((u16
)cntrs
.symbol_error_counter
);
1439 if (cntrs
.link_error_recovery_counter
> 0xFFUL
)
1440 p
->link_error_recovery_counter
= 0xFF;
1442 p
->link_error_recovery_counter
=
1443 (u8
)cntrs
.link_error_recovery_counter
;
1444 if (cntrs
.link_downed_counter
> 0xFFUL
)
1445 p
->link_downed_counter
= 0xFF;
1447 p
->link_downed_counter
= (u8
)cntrs
.link_downed_counter
;
1448 if (cntrs
.port_rcv_errors
> 0xFFFFUL
)
1449 p
->port_rcv_errors
= cpu_to_be16(0xFFFF);
1451 p
->port_rcv_errors
=
1452 cpu_to_be16((u16
) cntrs
.port_rcv_errors
);
1453 if (cntrs
.port_rcv_remphys_errors
> 0xFFFFUL
)
1454 p
->port_rcv_remphys_errors
= cpu_to_be16(0xFFFF);
1456 p
->port_rcv_remphys_errors
=
1457 cpu_to_be16((u16
)cntrs
.port_rcv_remphys_errors
);
1458 if (cntrs
.port_xmit_discards
> 0xFFFFUL
)
1459 p
->port_xmit_discards
= cpu_to_be16(0xFFFF);
1461 p
->port_xmit_discards
=
1462 cpu_to_be16((u16
)cntrs
.port_xmit_discards
);
1463 if (cntrs
.local_link_integrity_errors
> 0xFUL
)
1464 cntrs
.local_link_integrity_errors
= 0xFUL
;
1465 if (cntrs
.excessive_buffer_overrun_errors
> 0xFUL
)
1466 cntrs
.excessive_buffer_overrun_errors
= 0xFUL
;
1467 p
->lli_ebor_errors
= (cntrs
.local_link_integrity_errors
<< 4) |
1468 cntrs
.excessive_buffer_overrun_errors
;
1469 if (cntrs
.vl15_dropped
> 0xFFFFUL
)
1470 p
->vl15_dropped
= cpu_to_be16(0xFFFF);
1472 p
->vl15_dropped
= cpu_to_be16((u16
)cntrs
.vl15_dropped
);
1473 if (cntrs
.port_xmit_data
> 0xFFFFFFFFUL
)
1474 p
->port_xmit_data
= cpu_to_be32(0xFFFFFFFF);
1476 p
->port_xmit_data
= cpu_to_be32((u32
)cntrs
.port_xmit_data
);
1477 if (cntrs
.port_rcv_data
> 0xFFFFFFFFUL
)
1478 p
->port_rcv_data
= cpu_to_be32(0xFFFFFFFF);
1480 p
->port_rcv_data
= cpu_to_be32((u32
)cntrs
.port_rcv_data
);
1481 if (cntrs
.port_xmit_packets
> 0xFFFFFFFFUL
)
1482 p
->port_xmit_packets
= cpu_to_be32(0xFFFFFFFF);
1484 p
->port_xmit_packets
=
1485 cpu_to_be32((u32
)cntrs
.port_xmit_packets
);
1486 if (cntrs
.port_rcv_packets
> 0xFFFFFFFFUL
)
1487 p
->port_rcv_packets
= cpu_to_be32(0xFFFFFFFF);
1489 p
->port_rcv_packets
=
1490 cpu_to_be32((u32
) cntrs
.port_rcv_packets
);
1492 return reply((struct ib_smp
*) pmp
);
1495 static int pma_get_portcounters_cong(struct ib_perf
*pmp
,
1496 struct ib_device
*ibdev
, u8 port
)
1498 /* Congestion PMA packets start at offset 24 not 64 */
1499 struct ib_pma_portcounters_cong
*p
=
1500 (struct ib_pma_portcounters_cong
*)pmp
->reserved
;
1501 struct qib_verbs_counters cntrs
;
1502 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1503 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1504 struct qib_devdata
*dd
= dd_from_ppd(ppd
);
1505 u32 port_select
= be32_to_cpu(pmp
->attr_mod
) & 0xFF;
1506 u64 xmit_wait_counter
;
1507 unsigned long flags
;
1510 * This check is performed only in the GET method because the
1511 * SET method ends up calling this anyway.
1513 if (!dd
->psxmitwait_supported
)
1514 pmp
->status
|= IB_SMP_UNSUP_METH_ATTR
;
1515 if (port_select
!= port
)
1516 pmp
->status
|= IB_SMP_INVALID_FIELD
;
1518 qib_get_counters(ppd
, &cntrs
);
1519 spin_lock_irqsave(&ppd
->ibport_data
.lock
, flags
);
1520 xmit_wait_counter
= xmit_wait_get_value_delta(ppd
);
1521 spin_unlock_irqrestore(&ppd
->ibport_data
.lock
, flags
);
1523 /* Adjust counters for any resets done. */
1524 cntrs
.symbol_error_counter
-= ibp
->z_symbol_error_counter
;
1525 cntrs
.link_error_recovery_counter
-=
1526 ibp
->z_link_error_recovery_counter
;
1527 cntrs
.link_downed_counter
-= ibp
->z_link_downed_counter
;
1528 cntrs
.port_rcv_errors
-= ibp
->z_port_rcv_errors
;
1529 cntrs
.port_rcv_remphys_errors
-=
1530 ibp
->z_port_rcv_remphys_errors
;
1531 cntrs
.port_xmit_discards
-= ibp
->z_port_xmit_discards
;
1532 cntrs
.local_link_integrity_errors
-=
1533 ibp
->z_local_link_integrity_errors
;
1534 cntrs
.excessive_buffer_overrun_errors
-=
1535 ibp
->z_excessive_buffer_overrun_errors
;
1536 cntrs
.vl15_dropped
-= ibp
->z_vl15_dropped
;
1537 cntrs
.vl15_dropped
+= ibp
->n_vl15_dropped
;
1538 cntrs
.port_xmit_data
-= ibp
->z_port_xmit_data
;
1539 cntrs
.port_rcv_data
-= ibp
->z_port_rcv_data
;
1540 cntrs
.port_xmit_packets
-= ibp
->z_port_xmit_packets
;
1541 cntrs
.port_rcv_packets
-= ibp
->z_port_rcv_packets
;
1543 memset(pmp
->reserved
, 0, sizeof(pmp
->reserved
) +
1547 * Set top 3 bits to indicate interval in picoseconds in
1550 p
->port_check_rate
=
1551 cpu_to_be16((QIB_XMIT_RATE_PICO
<< 13) |
1552 (dd
->psxmitwait_check_rate
&
1553 ~(QIB_XMIT_RATE_PICO
<< 13)));
1554 p
->port_adr_events
= cpu_to_be64(0);
1555 p
->port_xmit_wait
= cpu_to_be64(xmit_wait_counter
);
1556 p
->port_xmit_data
= cpu_to_be64(cntrs
.port_xmit_data
);
1557 p
->port_rcv_data
= cpu_to_be64(cntrs
.port_rcv_data
);
1558 p
->port_xmit_packets
=
1559 cpu_to_be64(cntrs
.port_xmit_packets
);
1560 p
->port_rcv_packets
=
1561 cpu_to_be64(cntrs
.port_rcv_packets
);
1562 if (cntrs
.symbol_error_counter
> 0xFFFFUL
)
1563 p
->symbol_error_counter
= cpu_to_be16(0xFFFF);
1565 p
->symbol_error_counter
=
1567 (u16
)cntrs
.symbol_error_counter
);
1568 if (cntrs
.link_error_recovery_counter
> 0xFFUL
)
1569 p
->link_error_recovery_counter
= 0xFF;
1571 p
->link_error_recovery_counter
=
1572 (u8
)cntrs
.link_error_recovery_counter
;
1573 if (cntrs
.link_downed_counter
> 0xFFUL
)
1574 p
->link_downed_counter
= 0xFF;
1576 p
->link_downed_counter
=
1577 (u8
)cntrs
.link_downed_counter
;
1578 if (cntrs
.port_rcv_errors
> 0xFFFFUL
)
1579 p
->port_rcv_errors
= cpu_to_be16(0xFFFF);
1581 p
->port_rcv_errors
=
1582 cpu_to_be16((u16
) cntrs
.port_rcv_errors
);
1583 if (cntrs
.port_rcv_remphys_errors
> 0xFFFFUL
)
1584 p
->port_rcv_remphys_errors
= cpu_to_be16(0xFFFF);
1586 p
->port_rcv_remphys_errors
=
1588 (u16
)cntrs
.port_rcv_remphys_errors
);
1589 if (cntrs
.port_xmit_discards
> 0xFFFFUL
)
1590 p
->port_xmit_discards
= cpu_to_be16(0xFFFF);
1592 p
->port_xmit_discards
=
1593 cpu_to_be16((u16
)cntrs
.port_xmit_discards
);
1594 if (cntrs
.local_link_integrity_errors
> 0xFUL
)
1595 cntrs
.local_link_integrity_errors
= 0xFUL
;
1596 if (cntrs
.excessive_buffer_overrun_errors
> 0xFUL
)
1597 cntrs
.excessive_buffer_overrun_errors
= 0xFUL
;
1598 p
->lli_ebor_errors
= (cntrs
.local_link_integrity_errors
<< 4) |
1599 cntrs
.excessive_buffer_overrun_errors
;
1600 if (cntrs
.vl15_dropped
> 0xFFFFUL
)
1601 p
->vl15_dropped
= cpu_to_be16(0xFFFF);
1603 p
->vl15_dropped
= cpu_to_be16((u16
)cntrs
.vl15_dropped
);
1605 return reply((struct ib_smp
*)pmp
);
1608 static int pma_get_portcounters_ext(struct ib_perf
*pmp
,
1609 struct ib_device
*ibdev
, u8 port
)
1611 struct ib_pma_portcounters_ext
*p
=
1612 (struct ib_pma_portcounters_ext
*)pmp
->data
;
1613 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1614 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1615 u64 swords
, rwords
, spkts
, rpkts
, xwait
;
1616 u8 port_select
= p
->port_select
;
1618 memset(pmp
->data
, 0, sizeof(pmp
->data
));
1620 p
->port_select
= port_select
;
1621 if (pmp
->attr_mod
!= 0 || port_select
!= port
) {
1622 pmp
->status
|= IB_SMP_INVALID_FIELD
;
1626 qib_snapshot_counters(ppd
, &swords
, &rwords
, &spkts
, &rpkts
, &xwait
);
1628 /* Adjust counters for any resets done. */
1629 swords
-= ibp
->z_port_xmit_data
;
1630 rwords
-= ibp
->z_port_rcv_data
;
1631 spkts
-= ibp
->z_port_xmit_packets
;
1632 rpkts
-= ibp
->z_port_rcv_packets
;
1634 p
->port_xmit_data
= cpu_to_be64(swords
);
1635 p
->port_rcv_data
= cpu_to_be64(rwords
);
1636 p
->port_xmit_packets
= cpu_to_be64(spkts
);
1637 p
->port_rcv_packets
= cpu_to_be64(rpkts
);
1638 p
->port_unicast_xmit_packets
= cpu_to_be64(ibp
->n_unicast_xmit
);
1639 p
->port_unicast_rcv_packets
= cpu_to_be64(ibp
->n_unicast_rcv
);
1640 p
->port_multicast_xmit_packets
= cpu_to_be64(ibp
->n_multicast_xmit
);
1641 p
->port_multicast_rcv_packets
= cpu_to_be64(ibp
->n_multicast_rcv
);
1644 return reply((struct ib_smp
*) pmp
);
1647 static int pma_set_portcounters(struct ib_perf
*pmp
,
1648 struct ib_device
*ibdev
, u8 port
)
1650 struct ib_pma_portcounters
*p
= (struct ib_pma_portcounters
*)
1652 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1653 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1654 struct qib_verbs_counters cntrs
;
1657 * Since the HW doesn't support clearing counters, we save the
1658 * current count and subtract it from future responses.
1660 qib_get_counters(ppd
, &cntrs
);
1662 if (p
->counter_select
& IB_PMA_SEL_SYMBOL_ERROR
)
1663 ibp
->z_symbol_error_counter
= cntrs
.symbol_error_counter
;
1665 if (p
->counter_select
& IB_PMA_SEL_LINK_ERROR_RECOVERY
)
1666 ibp
->z_link_error_recovery_counter
=
1667 cntrs
.link_error_recovery_counter
;
1669 if (p
->counter_select
& IB_PMA_SEL_LINK_DOWNED
)
1670 ibp
->z_link_downed_counter
= cntrs
.link_downed_counter
;
1672 if (p
->counter_select
& IB_PMA_SEL_PORT_RCV_ERRORS
)
1673 ibp
->z_port_rcv_errors
= cntrs
.port_rcv_errors
;
1675 if (p
->counter_select
& IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS
)
1676 ibp
->z_port_rcv_remphys_errors
=
1677 cntrs
.port_rcv_remphys_errors
;
1679 if (p
->counter_select
& IB_PMA_SEL_PORT_XMIT_DISCARDS
)
1680 ibp
->z_port_xmit_discards
= cntrs
.port_xmit_discards
;
1682 if (p
->counter_select
& IB_PMA_SEL_LOCAL_LINK_INTEGRITY_ERRORS
)
1683 ibp
->z_local_link_integrity_errors
=
1684 cntrs
.local_link_integrity_errors
;
1686 if (p
->counter_select
& IB_PMA_SEL_EXCESSIVE_BUFFER_OVERRUNS
)
1687 ibp
->z_excessive_buffer_overrun_errors
=
1688 cntrs
.excessive_buffer_overrun_errors
;
1690 if (p
->counter_select
& IB_PMA_SEL_PORT_VL15_DROPPED
) {
1691 ibp
->n_vl15_dropped
= 0;
1692 ibp
->z_vl15_dropped
= cntrs
.vl15_dropped
;
1695 if (p
->counter_select
& IB_PMA_SEL_PORT_XMIT_DATA
)
1696 ibp
->z_port_xmit_data
= cntrs
.port_xmit_data
;
1698 if (p
->counter_select
& IB_PMA_SEL_PORT_RCV_DATA
)
1699 ibp
->z_port_rcv_data
= cntrs
.port_rcv_data
;
1701 if (p
->counter_select
& IB_PMA_SEL_PORT_XMIT_PACKETS
)
1702 ibp
->z_port_xmit_packets
= cntrs
.port_xmit_packets
;
1704 if (p
->counter_select
& IB_PMA_SEL_PORT_RCV_PACKETS
)
1705 ibp
->z_port_rcv_packets
= cntrs
.port_rcv_packets
;
1707 return pma_get_portcounters(pmp
, ibdev
, port
);
1710 static int pma_set_portcounters_cong(struct ib_perf
*pmp
,
1711 struct ib_device
*ibdev
, u8 port
)
1713 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1714 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1715 struct qib_devdata
*dd
= dd_from_ppd(ppd
);
1716 struct qib_verbs_counters cntrs
;
1717 u32 counter_select
= (be32_to_cpu(pmp
->attr_mod
) >> 24) & 0xFF;
1719 unsigned long flags
;
1721 qib_get_counters(ppd
, &cntrs
);
1722 /* Get counter values before we save them */
1723 ret
= pma_get_portcounters_cong(pmp
, ibdev
, port
);
1725 if (counter_select
& IB_PMA_SEL_CONG_XMIT
) {
1726 spin_lock_irqsave(&ppd
->ibport_data
.lock
, flags
);
1727 ppd
->cong_stats
.counter
= 0;
1728 dd
->f_set_cntr_sample(ppd
, QIB_CONG_TIMER_PSINTERVAL
,
1730 spin_unlock_irqrestore(&ppd
->ibport_data
.lock
, flags
);
1732 if (counter_select
& IB_PMA_SEL_CONG_PORT_DATA
) {
1733 ibp
->z_port_xmit_data
= cntrs
.port_xmit_data
;
1734 ibp
->z_port_rcv_data
= cntrs
.port_rcv_data
;
1735 ibp
->z_port_xmit_packets
= cntrs
.port_xmit_packets
;
1736 ibp
->z_port_rcv_packets
= cntrs
.port_rcv_packets
;
1738 if (counter_select
& IB_PMA_SEL_CONG_ALL
) {
1739 ibp
->z_symbol_error_counter
=
1740 cntrs
.symbol_error_counter
;
1741 ibp
->z_link_error_recovery_counter
=
1742 cntrs
.link_error_recovery_counter
;
1743 ibp
->z_link_downed_counter
=
1744 cntrs
.link_downed_counter
;
1745 ibp
->z_port_rcv_errors
= cntrs
.port_rcv_errors
;
1746 ibp
->z_port_rcv_remphys_errors
=
1747 cntrs
.port_rcv_remphys_errors
;
1748 ibp
->z_port_xmit_discards
=
1749 cntrs
.port_xmit_discards
;
1750 ibp
->z_local_link_integrity_errors
=
1751 cntrs
.local_link_integrity_errors
;
1752 ibp
->z_excessive_buffer_overrun_errors
=
1753 cntrs
.excessive_buffer_overrun_errors
;
1754 ibp
->n_vl15_dropped
= 0;
1755 ibp
->z_vl15_dropped
= cntrs
.vl15_dropped
;
1761 static int pma_set_portcounters_ext(struct ib_perf
*pmp
,
1762 struct ib_device
*ibdev
, u8 port
)
1764 struct ib_pma_portcounters
*p
= (struct ib_pma_portcounters
*)
1766 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1767 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1768 u64 swords
, rwords
, spkts
, rpkts
, xwait
;
1770 qib_snapshot_counters(ppd
, &swords
, &rwords
, &spkts
, &rpkts
, &xwait
);
1772 if (p
->counter_select
& IB_PMA_SELX_PORT_XMIT_DATA
)
1773 ibp
->z_port_xmit_data
= swords
;
1775 if (p
->counter_select
& IB_PMA_SELX_PORT_RCV_DATA
)
1776 ibp
->z_port_rcv_data
= rwords
;
1778 if (p
->counter_select
& IB_PMA_SELX_PORT_XMIT_PACKETS
)
1779 ibp
->z_port_xmit_packets
= spkts
;
1781 if (p
->counter_select
& IB_PMA_SELX_PORT_RCV_PACKETS
)
1782 ibp
->z_port_rcv_packets
= rpkts
;
1784 if (p
->counter_select
& IB_PMA_SELX_PORT_UNI_XMIT_PACKETS
)
1785 ibp
->n_unicast_xmit
= 0;
1787 if (p
->counter_select
& IB_PMA_SELX_PORT_UNI_RCV_PACKETS
)
1788 ibp
->n_unicast_rcv
= 0;
1790 if (p
->counter_select
& IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS
)
1791 ibp
->n_multicast_xmit
= 0;
1793 if (p
->counter_select
& IB_PMA_SELX_PORT_MULTI_RCV_PACKETS
)
1794 ibp
->n_multicast_rcv
= 0;
1796 return pma_get_portcounters_ext(pmp
, ibdev
, port
);
1799 static int process_subn(struct ib_device
*ibdev
, int mad_flags
,
1800 u8 port
, struct ib_mad
*in_mad
,
1801 struct ib_mad
*out_mad
)
1803 struct ib_smp
*smp
= (struct ib_smp
*)out_mad
;
1804 struct qib_ibport
*ibp
= to_iport(ibdev
, port
);
1805 struct qib_pportdata
*ppd
= ppd_from_ibp(ibp
);
1809 if (smp
->class_version
!= 1) {
1810 smp
->status
|= IB_SMP_UNSUP_VERSION
;
1815 ret
= check_mkey(ibp
, smp
, mad_flags
);
1817 u32 port_num
= be32_to_cpu(smp
->attr_mod
);
1820 * If this is a get/set portinfo, we already check the
1821 * M_Key if the MAD is for another port and the M_Key
1822 * is OK on the receiving port. This check is needed
1823 * to increment the error counters when the M_Key
1824 * fails to match on *both* ports.
1826 if (in_mad
->mad_hdr
.attr_id
== IB_SMP_ATTR_PORT_INFO
&&
1827 (smp
->method
== IB_MGMT_METHOD_GET
||
1828 smp
->method
== IB_MGMT_METHOD_SET
) &&
1829 port_num
&& port_num
<= ibdev
->phys_port_cnt
&&
1831 (void) check_mkey(to_iport(ibdev
, port_num
), smp
, 0);
1835 switch (smp
->method
) {
1836 case IB_MGMT_METHOD_GET
:
1837 switch (smp
->attr_id
) {
1838 case IB_SMP_ATTR_NODE_DESC
:
1839 ret
= subn_get_nodedescription(smp
, ibdev
);
1841 case IB_SMP_ATTR_NODE_INFO
:
1842 ret
= subn_get_nodeinfo(smp
, ibdev
, port
);
1844 case IB_SMP_ATTR_GUID_INFO
:
1845 ret
= subn_get_guidinfo(smp
, ibdev
, port
);
1847 case IB_SMP_ATTR_PORT_INFO
:
1848 ret
= subn_get_portinfo(smp
, ibdev
, port
);
1850 case IB_SMP_ATTR_PKEY_TABLE
:
1851 ret
= subn_get_pkeytable(smp
, ibdev
, port
);
1853 case IB_SMP_ATTR_SL_TO_VL_TABLE
:
1854 ret
= subn_get_sl_to_vl(smp
, ibdev
, port
);
1856 case IB_SMP_ATTR_VL_ARB_TABLE
:
1857 ret
= subn_get_vl_arb(smp
, ibdev
, port
);
1859 case IB_SMP_ATTR_SM_INFO
:
1860 if (ibp
->port_cap_flags
& IB_PORT_SM_DISABLED
) {
1861 ret
= IB_MAD_RESULT_SUCCESS
|
1862 IB_MAD_RESULT_CONSUMED
;
1865 if (ibp
->port_cap_flags
& IB_PORT_SM
) {
1866 ret
= IB_MAD_RESULT_SUCCESS
;
1871 smp
->status
|= IB_SMP_UNSUP_METH_ATTR
;
1876 case IB_MGMT_METHOD_SET
:
1877 switch (smp
->attr_id
) {
1878 case IB_SMP_ATTR_GUID_INFO
:
1879 ret
= subn_set_guidinfo(smp
, ibdev
, port
);
1881 case IB_SMP_ATTR_PORT_INFO
:
1882 ret
= subn_set_portinfo(smp
, ibdev
, port
);
1884 case IB_SMP_ATTR_PKEY_TABLE
:
1885 ret
= subn_set_pkeytable(smp
, ibdev
, port
);
1887 case IB_SMP_ATTR_SL_TO_VL_TABLE
:
1888 ret
= subn_set_sl_to_vl(smp
, ibdev
, port
);
1890 case IB_SMP_ATTR_VL_ARB_TABLE
:
1891 ret
= subn_set_vl_arb(smp
, ibdev
, port
);
1893 case IB_SMP_ATTR_SM_INFO
:
1894 if (ibp
->port_cap_flags
& IB_PORT_SM_DISABLED
) {
1895 ret
= IB_MAD_RESULT_SUCCESS
|
1896 IB_MAD_RESULT_CONSUMED
;
1899 if (ibp
->port_cap_flags
& IB_PORT_SM
) {
1900 ret
= IB_MAD_RESULT_SUCCESS
;
1905 smp
->status
|= IB_SMP_UNSUP_METH_ATTR
;
1910 case IB_MGMT_METHOD_TRAP_REPRESS
:
1911 if (smp
->attr_id
== IB_SMP_ATTR_NOTICE
)
1912 ret
= subn_trap_repress(smp
, ibdev
, port
);
1914 smp
->status
|= IB_SMP_UNSUP_METH_ATTR
;
1919 case IB_MGMT_METHOD_TRAP
:
1920 case IB_MGMT_METHOD_REPORT
:
1921 case IB_MGMT_METHOD_REPORT_RESP
:
1922 case IB_MGMT_METHOD_GET_RESP
:
1924 * The ib_mad module will call us to process responses
1925 * before checking for other consumers.
1926 * Just tell the caller to process it normally.
1928 ret
= IB_MAD_RESULT_SUCCESS
;
1931 case IB_MGMT_METHOD_SEND
:
1932 if (ib_get_smp_direction(smp
) &&
1933 smp
->attr_id
== QIB_VENDOR_IPG
) {
1934 ppd
->dd
->f_set_ib_cfg(ppd
, QIB_IB_CFG_PORT
,
1936 ret
= IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_CONSUMED
;
1938 ret
= IB_MAD_RESULT_SUCCESS
;
1942 smp
->status
|= IB_SMP_UNSUP_METHOD
;
1950 static int process_perf(struct ib_device
*ibdev
, u8 port
,
1951 struct ib_mad
*in_mad
,
1952 struct ib_mad
*out_mad
)
1954 struct ib_perf
*pmp
= (struct ib_perf
*)out_mad
;
1958 if (pmp
->class_version
!= 1) {
1959 pmp
->status
|= IB_SMP_UNSUP_VERSION
;
1960 ret
= reply((struct ib_smp
*) pmp
);
1964 switch (pmp
->method
) {
1965 case IB_MGMT_METHOD_GET
:
1966 switch (pmp
->attr_id
) {
1967 case IB_PMA_CLASS_PORT_INFO
:
1968 ret
= pma_get_classportinfo(pmp
, ibdev
);
1970 case IB_PMA_PORT_SAMPLES_CONTROL
:
1971 ret
= pma_get_portsamplescontrol(pmp
, ibdev
, port
);
1973 case IB_PMA_PORT_SAMPLES_RESULT
:
1974 ret
= pma_get_portsamplesresult(pmp
, ibdev
, port
);
1976 case IB_PMA_PORT_SAMPLES_RESULT_EXT
:
1977 ret
= pma_get_portsamplesresult_ext(pmp
, ibdev
, port
);
1979 case IB_PMA_PORT_COUNTERS
:
1980 ret
= pma_get_portcounters(pmp
, ibdev
, port
);
1982 case IB_PMA_PORT_COUNTERS_EXT
:
1983 ret
= pma_get_portcounters_ext(pmp
, ibdev
, port
);
1985 case IB_PMA_PORT_COUNTERS_CONG
:
1986 ret
= pma_get_portcounters_cong(pmp
, ibdev
, port
);
1989 pmp
->status
|= IB_SMP_UNSUP_METH_ATTR
;
1990 ret
= reply((struct ib_smp
*) pmp
);
1994 case IB_MGMT_METHOD_SET
:
1995 switch (pmp
->attr_id
) {
1996 case IB_PMA_PORT_SAMPLES_CONTROL
:
1997 ret
= pma_set_portsamplescontrol(pmp
, ibdev
, port
);
1999 case IB_PMA_PORT_COUNTERS
:
2000 ret
= pma_set_portcounters(pmp
, ibdev
, port
);
2002 case IB_PMA_PORT_COUNTERS_EXT
:
2003 ret
= pma_set_portcounters_ext(pmp
, ibdev
, port
);
2005 case IB_PMA_PORT_COUNTERS_CONG
:
2006 ret
= pma_set_portcounters_cong(pmp
, ibdev
, port
);
2009 pmp
->status
|= IB_SMP_UNSUP_METH_ATTR
;
2010 ret
= reply((struct ib_smp
*) pmp
);
2014 case IB_MGMT_METHOD_TRAP
:
2015 case IB_MGMT_METHOD_GET_RESP
:
2017 * The ib_mad module will call us to process responses
2018 * before checking for other consumers.
2019 * Just tell the caller to process it normally.
2021 ret
= IB_MAD_RESULT_SUCCESS
;
2025 pmp
->status
|= IB_SMP_UNSUP_METHOD
;
2026 ret
= reply((struct ib_smp
*) pmp
);
2034 * qib_process_mad - process an incoming MAD packet
2035 * @ibdev: the infiniband device this packet came in on
2036 * @mad_flags: MAD flags
2037 * @port: the port number this packet came in on
2038 * @in_wc: the work completion entry for this packet
2039 * @in_grh: the global route header for this packet
2040 * @in_mad: the incoming MAD
2041 * @out_mad: any outgoing MAD reply
2043 * Returns IB_MAD_RESULT_SUCCESS if this is a MAD that we are not
2044 * interested in processing.
2046 * Note that the verbs framework has already done the MAD sanity checks,
2047 * and hop count/pointer updating for IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE
2050 * This is called by the ib_mad module.
2052 int qib_process_mad(struct ib_device
*ibdev
, int mad_flags
, u8 port
,
2053 struct ib_wc
*in_wc
, struct ib_grh
*in_grh
,
2054 struct ib_mad
*in_mad
, struct ib_mad
*out_mad
)
2058 switch (in_mad
->mad_hdr
.mgmt_class
) {
2059 case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE
:
2060 case IB_MGMT_CLASS_SUBN_LID_ROUTED
:
2061 ret
= process_subn(ibdev
, mad_flags
, port
, in_mad
, out_mad
);
2064 case IB_MGMT_CLASS_PERF_MGMT
:
2065 ret
= process_perf(ibdev
, port
, in_mad
, out_mad
);
2069 ret
= IB_MAD_RESULT_SUCCESS
;
2076 static void send_handler(struct ib_mad_agent
*agent
,
2077 struct ib_mad_send_wc
*mad_send_wc
)
2079 ib_free_send_mad(mad_send_wc
->send_buf
);
2082 static void xmit_wait_timer_func(unsigned long opaque
)
2084 struct qib_pportdata
*ppd
= (struct qib_pportdata
*)opaque
;
2085 struct qib_devdata
*dd
= dd_from_ppd(ppd
);
2086 unsigned long flags
;
2089 spin_lock_irqsave(&ppd
->ibport_data
.lock
, flags
);
2090 if (ppd
->cong_stats
.flags
== IB_PMA_CONG_HW_CONTROL_SAMPLE
) {
2091 status
= dd
->f_portcntr(ppd
, QIBPORTCNTR_PSSTAT
);
2092 if (status
== IB_PMA_SAMPLE_STATUS_DONE
) {
2093 /* save counter cache */
2094 cache_hw_sample_counters(ppd
);
2095 ppd
->cong_stats
.flags
= IB_PMA_CONG_HW_CONTROL_TIMER
;
2099 ppd
->cong_stats
.counter
= xmit_wait_get_value_delta(ppd
);
2100 dd
->f_set_cntr_sample(ppd
, QIB_CONG_TIMER_PSINTERVAL
, 0x0);
2102 spin_unlock_irqrestore(&ppd
->ibport_data
.lock
, flags
);
2103 mod_timer(&ppd
->cong_stats
.timer
, jiffies
+ HZ
);
2106 int qib_create_agents(struct qib_ibdev
*dev
)
2108 struct qib_devdata
*dd
= dd_from_dev(dev
);
2109 struct ib_mad_agent
*agent
;
2110 struct qib_ibport
*ibp
;
2114 for (p
= 0; p
< dd
->num_pports
; p
++) {
2115 ibp
= &dd
->pport
[p
].ibport_data
;
2116 agent
= ib_register_mad_agent(&dev
->ibdev
, p
+ 1, IB_QPT_SMI
,
2117 NULL
, 0, send_handler
,
2119 if (IS_ERR(agent
)) {
2120 ret
= PTR_ERR(agent
);
2124 /* Initialize xmit_wait structure */
2125 dd
->pport
[p
].cong_stats
.counter
= 0;
2126 init_timer(&dd
->pport
[p
].cong_stats
.timer
);
2127 dd
->pport
[p
].cong_stats
.timer
.function
= xmit_wait_timer_func
;
2128 dd
->pport
[p
].cong_stats
.timer
.data
=
2129 (unsigned long)(&dd
->pport
[p
]);
2130 dd
->pport
[p
].cong_stats
.timer
.expires
= 0;
2131 add_timer(&dd
->pport
[p
].cong_stats
.timer
);
2133 ibp
->send_agent
= agent
;
2139 for (p
= 0; p
< dd
->num_pports
; p
++) {
2140 ibp
= &dd
->pport
[p
].ibport_data
;
2141 if (ibp
->send_agent
) {
2142 agent
= ibp
->send_agent
;
2143 ibp
->send_agent
= NULL
;
2144 ib_unregister_mad_agent(agent
);
2151 void qib_free_agents(struct qib_ibdev
*dev
)
2153 struct qib_devdata
*dd
= dd_from_dev(dev
);
2154 struct ib_mad_agent
*agent
;
2155 struct qib_ibport
*ibp
;
2158 for (p
= 0; p
< dd
->num_pports
; p
++) {
2159 ibp
= &dd
->pport
[p
].ibport_data
;
2160 if (ibp
->send_agent
) {
2161 agent
= ibp
->send_agent
;
2162 ibp
->send_agent
= NULL
;
2163 ib_unregister_mad_agent(agent
);
2166 ib_destroy_ah(&ibp
->sm_ah
->ibah
);
2169 if (dd
->pport
[p
].cong_stats
.timer
.data
)
2170 del_timer_sync(&dd
->pport
[p
].cong_stats
.timer
);