projects / deliverable / linux.git / blob
? search:


49acd1e15707095c66b8c7c97ea321e4c37e0ade
[deliverable/linux.git] / drivers / infiniband / hw / ipath / ipath_mad.c
1 /*
2 * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33 #include <rdma/ib_smi.h>
34
35 #include "ipath_kernel.h"
36 #include "ipath_verbs.h"
37 #include "ips_common.h"
38
39 #define IB_SMP_UNSUP_VERSION __constant_htons(0x0004)
40 #define IB_SMP_UNSUP_METHOD __constant_htons(0x0008)
41 #define IB_SMP_UNSUP_METH_ATTR __constant_htons(0x000C)
42 #define IB_SMP_INVALID_FIELD __constant_htons(0x001C)
43
44 static int reply(struct ib_smp *smp)
45 {
46 /*
47 * The verbs framework will handle the directed/LID route
48 * packet changes.
49 */
50 smp->method = IB_MGMT_METHOD_GET_RESP;
51 if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
52 smp->status |= IB_SMP_DIRECTION;
53 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
54 }
55
56 static int recv_subn_get_nodedescription(struct ib_smp *smp,
57 struct ib_device *ibdev)
58 {
59 if (smp->attr_mod)
60 smp->status |= IB_SMP_INVALID_FIELD;
61
62 strncpy(smp->data, ibdev->node_desc, sizeof(smp->data));
63
64 return reply(smp);
65 }
66
67 struct nodeinfo {
68 u8 base_version;
69 u8 class_version;
70 u8 node_type;
71 u8 num_ports;
72 __be64 sys_guid;
73 __be64 node_guid;
74 __be64 port_guid;
75 __be16 partition_cap;
76 __be16 device_id;
77 __be32 revision;
78 u8 local_port_num;
79 u8 vendor_id[3];
80 } __attribute__ ((packed));
81
82 static int recv_subn_get_nodeinfo(struct ib_smp *smp,
83 struct ib_device *ibdev, u8 port)
84 {
85 struct nodeinfo *nip = (struct nodeinfo *)&smp->data;
86 struct ipath_devdata *dd = to_idev(ibdev)->dd;
87 u32 vendor, boardid, majrev, minrev;
88
89 if (smp->attr_mod)
90 smp->status |= IB_SMP_INVALID_FIELD;
91
92 nip->base_version = 1;
93 nip->class_version = 1;
94 nip->node_type = 1; /* channel adapter */
95 /*
96 * XXX The num_ports value will need a layer function to get
97 * the value if we ever have more than one IB port on a chip.
98 * We will also need to get the GUID for the port.
99 */
100 nip->num_ports = ibdev->phys_port_cnt;
101 /* This is already in network order */
102 nip->sys_guid = to_idev(ibdev)->sys_image_guid;
103 nip->node_guid = ipath_layer_get_guid(dd);
104 nip->port_guid = nip->sys_guid;
105 nip->partition_cap = cpu_to_be16(ipath_layer_get_npkeys(dd));
106 nip->device_id = cpu_to_be16(ipath_layer_get_deviceid(dd));
107 ipath_layer_query_device(dd, &vendor, &boardid, &majrev, &minrev);
108 nip->revision = cpu_to_be32((majrev << 16) | minrev);
109 nip->local_port_num = port;
110 nip->vendor_id[0] = 0;
111 nip->vendor_id[1] = vendor >> 8;
112 nip->vendor_id[2] = vendor;
113
114 return reply(smp);
115 }
116
117 static int recv_subn_get_guidinfo(struct ib_smp *smp,
118 struct ib_device *ibdev)
119 {
120 u32 startgx = 8 * be32_to_cpu(smp->attr_mod);
121 __be64 *p = (__be64 *) smp->data;
122
123 /* 32 blocks of 8 64-bit GUIDs per block */
124
125 memset(smp->data, 0, sizeof(smp->data));
126
127 /*
128 * We only support one GUID for now. If this changes, the
129 * portinfo.guid_cap field needs to be updated too.
130 */
131 if (startgx == 0)
132 /* The first is a copy of the read-only HW GUID. */
133 *p = ipath_layer_get_guid(to_idev(ibdev)->dd);
134 else
135 smp->status |= IB_SMP_INVALID_FIELD;
136
137 return reply(smp);
138 }
139
140 static int recv_subn_get_portinfo(struct ib_smp *smp,
141 struct ib_device *ibdev, u8 port)
142 {
143 struct ipath_ibdev *dev;
144 struct ib_port_info *pip = (struct ib_port_info *)smp->data;
145 u16 lid;
146 u8 ibcstat;
147 u8 mtu;
148 int ret;
149
150 if (be32_to_cpu(smp->attr_mod) > ibdev->phys_port_cnt) {
151 smp->status |= IB_SMP_INVALID_FIELD;
152 ret = reply(smp);
153 goto bail;
154 }
155
156 dev = to_idev(ibdev);
157
158 /* Clear all fields. Only set the non-zero fields. */
159 memset(smp->data, 0, sizeof(smp->data));
160
161 /* Only return the mkey if the protection field allows it. */
162 if (smp->method == IB_MGMT_METHOD_SET || dev->mkey == smp->mkey ||
163 (dev->mkeyprot_resv_lmc >> 6) == 0)
164 pip->mkey = dev->mkey;
165 pip->gid_prefix = dev->gid_prefix;
166 lid = ipath_layer_get_lid(dev->dd);
167 pip->lid = lid ? cpu_to_be16(lid) : IB_LID_PERMISSIVE;
168 pip->sm_lid = cpu_to_be16(dev->sm_lid);
169 pip->cap_mask = cpu_to_be32(dev->port_cap_flags);
170 /* pip->diag_code; */
171 pip->mkey_lease_period = cpu_to_be16(dev->mkey_lease_period);
172 pip->local_port_num = port;
173 pip->link_width_enabled = dev->link_width_enabled;
174 pip->link_width_supported = 3; /* 1x or 4x */
175 pip->link_width_active = 2; /* 4x */
176 pip->linkspeed_portstate = 0x10; /* 2.5Gbps */
177 ibcstat = ipath_layer_get_lastibcstat(dev->dd);
178 pip->linkspeed_portstate |= ((ibcstat >> 4) & 0x3) + 1;
179 pip->portphysstate_linkdown =
180 (ipath_cvt_physportstate[ibcstat & 0xf] << 4) |
181 (ipath_layer_get_linkdowndefaultstate(dev->dd) ? 1 : 2);
182 pip->mkeyprot_resv_lmc = dev->mkeyprot_resv_lmc;
183 pip->linkspeedactive_enabled = 0x11; /* 2.5Gbps, 2.5Gbps */
184 switch (ipath_layer_get_ibmtu(dev->dd)) {
185 case 4096:
186 mtu = IB_MTU_4096;
187 break;
188 case 2048:
189 mtu = IB_MTU_2048;
190 break;
191 case 1024:
192 mtu = IB_MTU_1024;
193 break;
194 case 512:
195 mtu = IB_MTU_512;
196 break;
197 case 256:
198 mtu = IB_MTU_256;
199 break;
200 default: /* oops, something is wrong */
201 mtu = IB_MTU_2048;
202 break;
203 }
204 pip->neighbormtu_mastersmsl = (mtu << 4) | dev->sm_sl;
205 pip->vlcap_inittype = 0x10; /* VLCap = VL0, InitType = 0 */
206 pip->vl_high_limit = dev->vl_high_limit;
207 /* pip->vl_arb_high_cap; // only one VL */
208 /* pip->vl_arb_low_cap; // only one VL */
209 /* InitTypeReply = 0 */
210 pip->inittypereply_mtucap = IB_MTU_4096;
211 // HCAs ignore VLStallCount and HOQLife
212 /* pip->vlstallcnt_hoqlife; */
213 pip->operationalvl_pei_peo_fpi_fpo = 0x10; /* OVLs = 1 */
214 pip->mkey_violations = cpu_to_be16(dev->mkey_violations);
215 /* P_KeyViolations are counted by hardware. */
216 pip->pkey_violations =
217 cpu_to_be16((ipath_layer_get_cr_errpkey(dev->dd) -
218 dev->n_pkey_violations) & 0xFFFF);
219 pip->qkey_violations = cpu_to_be16(dev->qkey_violations);
220 /* Only the hardware GUID is supported for now */
221 pip->guid_cap = 1;
222 pip->clientrereg_resv_subnetto = dev->subnet_timeout;
223 /* 32.768 usec. response time (guessing) */
224 pip->resv_resptimevalue = 3;
225 pip->localphyerrors_overrunerrors =
226 (ipath_layer_get_phyerrthreshold(dev->dd) << 4) |
227 ipath_layer_get_overrunthreshold(dev->dd);
228 /* pip->max_credit_hint; */
229 /* pip->link_roundtrip_latency[3]; */
230
231 ret = reply(smp);
232
233 bail:
234 return ret;
235 }
236
237 static int recv_subn_get_pkeytable(struct ib_smp *smp,
238 struct ib_device *ibdev)
239 {
240 u32 startpx = 32 * (be32_to_cpu(smp->attr_mod) & 0xffff);
241 u16 *p = (u16 *) smp->data;
242 __be16 *q = (__be16 *) smp->data;
243
244 /* 64 blocks of 32 16-bit P_Key entries */
245
246 memset(smp->data, 0, sizeof(smp->data));
247 if (startpx == 0) {
248 struct ipath_ibdev *dev = to_idev(ibdev);
249 unsigned i, n = ipath_layer_get_npkeys(dev->dd);
250
251 ipath_layer_get_pkeys(dev->dd, p);
252
253 for (i = 0; i < n; i++)
254 q[i] = cpu_to_be16(p[i]);
255 } else
256 smp->status |= IB_SMP_INVALID_FIELD;
257
258 return reply(smp);
259 }
260
261 static int recv_subn_set_guidinfo(struct ib_smp *smp,
262 struct ib_device *ibdev)
263 {
264 /* The only GUID we support is the first read-only entry. */
265 return recv_subn_get_guidinfo(smp, ibdev);
266 }
267
268 /**
269 * recv_subn_set_portinfo - set port information
270 * @smp: the incoming SM packet
271 * @ibdev: the infiniband device
272 * @port: the port on the device
273 *
274 * Set Portinfo (see ch. 14.2.5.6).
275 */
276 static int recv_subn_set_portinfo(struct ib_smp *smp,
277 struct ib_device *ibdev, u8 port)
278 {
279 struct ib_port_info *pip = (struct ib_port_info *)smp->data;
280 struct ib_event event;
281 struct ipath_ibdev *dev;
282 u32 flags;
283 char clientrereg = 0;
284 u16 lid, smlid;
285 u8 lwe;
286 u8 lse;
287 u8 state;
288 u16 lstate;
289 u32 mtu;
290 int ret;
291
292 if (be32_to_cpu(smp->attr_mod) > ibdev->phys_port_cnt)
293 goto err;
294
295 dev = to_idev(ibdev);
296 event.device = ibdev;
297 event.element.port_num = port;
298
299 dev->mkey = pip->mkey;
300 dev->gid_prefix = pip->gid_prefix;
301 dev->mkey_lease_period = be16_to_cpu(pip->mkey_lease_period);
302
303 lid = be16_to_cpu(pip->lid);
304 if (lid != ipath_layer_get_lid(dev->dd)) {
305 /* Must be a valid unicast LID address. */
306 if (lid == 0 || lid >= IPS_MULTICAST_LID_BASE)
307 goto err;
308 ipath_set_sps_lid(dev->dd, lid, pip->mkeyprot_resv_lmc & 7);
309 event.event = IB_EVENT_LID_CHANGE;
310 ib_dispatch_event(&event);
311 }
312
313 smlid = be16_to_cpu(pip->sm_lid);
314 if (smlid != dev->sm_lid) {
315 /* Must be a valid unicast LID address. */
316 if (smlid == 0 || smlid >= IPS_MULTICAST_LID_BASE)
317 goto err;
318 dev->sm_lid = smlid;
319 event.event = IB_EVENT_SM_CHANGE;
320 ib_dispatch_event(&event);
321 }
322
323 /* Only 4x supported but allow 1x or 4x to be set (see 14.2.6.6). */
324 lwe = pip->link_width_enabled;
325 if ((lwe >= 4 && lwe <= 8) || (lwe >= 0xC && lwe <= 0xFE))
326 goto err;
327 if (lwe == 0xFF)
328 dev->link_width_enabled = 3; /* 1x or 4x */
329 else if (lwe)
330 dev->link_width_enabled = lwe;
331
332 /* Only 2.5 Gbs supported. */
333 lse = pip->linkspeedactive_enabled & 0xF;
334 if (lse >= 2 && lse <= 0xE)
335 goto err;
336
337 /* Set link down default state. */
338 switch (pip->portphysstate_linkdown & 0xF) {
339 case 0: /* NOP */
340 break;
341 case 1: /* SLEEP */
342 if (ipath_layer_set_linkdowndefaultstate(dev->dd, 1))
343 goto err;
344 break;
345 case 2: /* POLL */
346 if (ipath_layer_set_linkdowndefaultstate(dev->dd, 0))
347 goto err;
348 break;
349 default:
350 goto err;
351 }
352
353 dev->mkeyprot_resv_lmc = pip->mkeyprot_resv_lmc;
354 dev->vl_high_limit = pip->vl_high_limit;
355
356 switch ((pip->neighbormtu_mastersmsl >> 4) & 0xF) {
357 case IB_MTU_256:
358 mtu = 256;
359 break;
360 case IB_MTU_512:
361 mtu = 512;
362 break;
363 case IB_MTU_1024:
364 mtu = 1024;
365 break;
366 case IB_MTU_2048:
367 mtu = 2048;
368 break;
369 case IB_MTU_4096:
370 mtu = 4096;
371 break;
372 default:
373 /* XXX We have already partially updated our state! */
374 goto err;
375 }
376 ipath_layer_set_mtu(dev->dd, mtu);
377
378 dev->sm_sl = pip->neighbormtu_mastersmsl & 0xF;
379
380 /* We only support VL0 */
381 if (((pip->operationalvl_pei_peo_fpi_fpo >> 4) & 0xF) > 1)
382 goto err;
383
384 if (pip->mkey_violations == 0)
385 dev->mkey_violations = 0;
386
387 /*
388 * Hardware counter can't be reset so snapshot and subtract
389 * later.
390 */
391 if (pip->pkey_violations == 0)
392 dev->n_pkey_violations =
393 ipath_layer_get_cr_errpkey(dev->dd);
394
395 if (pip->qkey_violations == 0)
396 dev->qkey_violations = 0;
397
398 if (ipath_layer_set_phyerrthreshold(
399 dev->dd,
400 (pip->localphyerrors_overrunerrors >> 4) & 0xF))
401 goto err;
402
403 if (ipath_layer_set_overrunthreshold(
404 dev->dd,
405 (pip->localphyerrors_overrunerrors & 0xF)))
406 goto err;
407
408 dev->subnet_timeout = pip->clientrereg_resv_subnetto & 0x1F;
409
410 if (pip->clientrereg_resv_subnetto & 0x80) {
411 clientrereg = 1;
412 event.event = IB_EVENT_LID_CHANGE;
413 ib_dispatch_event(&event);
414 }
415
416 /*
417 * Do the port state change now that the other link parameters
418 * have been set.
419 * Changing the port physical state only makes sense if the link
420 * is down or is being set to down.
421 */
422 state = pip->linkspeed_portstate & 0xF;
423 flags = ipath_layer_get_flags(dev->dd);
424 lstate = (pip->portphysstate_linkdown >> 4) & 0xF;
425 if (lstate && !(state == IB_PORT_DOWN || state == IB_PORT_NOP))
426 goto err;
427
428 /*
429 * Only state changes of DOWN, ARM, and ACTIVE are valid
430 * and must be in the correct state to take effect (see 7.2.6).
431 */
432 switch (state) {
433 case IB_PORT_NOP:
434 if (lstate == 0)
435 break;
436 /* FALLTHROUGH */
437 case IB_PORT_DOWN:
438 if (lstate == 0)
439 if (ipath_layer_get_linkdowndefaultstate(dev->dd))
440 lstate = IPATH_IB_LINKDOWN_SLEEP;
441 else
442 lstate = IPATH_IB_LINKDOWN;
443 else if (lstate == 1)
444 lstate = IPATH_IB_LINKDOWN_SLEEP;
445 else if (lstate == 2)
446 lstate = IPATH_IB_LINKDOWN;
447 else if (lstate == 3)
448 lstate = IPATH_IB_LINKDOWN_DISABLE;
449 else
450 goto err;
451 ipath_layer_set_linkstate(dev->dd, lstate);
452 if (flags & IPATH_LINKACTIVE) {
453 event.event = IB_EVENT_PORT_ERR;
454 ib_dispatch_event(&event);
455 }
456 break;
457 case IB_PORT_ARMED:
458 if (!(flags & (IPATH_LINKINIT | IPATH_LINKACTIVE)))
459 break;
460 ipath_layer_set_linkstate(dev->dd, IPATH_IB_LINKARM);
461 if (flags & IPATH_LINKACTIVE) {
462 event.event = IB_EVENT_PORT_ERR;
463 ib_dispatch_event(&event);
464 }
465 break;
466 case IB_PORT_ACTIVE:
467 if (!(flags & IPATH_LINKARMED))
468 break;
469 ipath_layer_set_linkstate(dev->dd, IPATH_IB_LINKACTIVE);
470 event.event = IB_EVENT_PORT_ACTIVE;
471 ib_dispatch_event(&event);
472 break;
473 default:
474 /* XXX We have already partially updated our state! */
475 goto err;
476 }
477
478 ret = recv_subn_get_portinfo(smp, ibdev, port);
479
480 if (clientrereg)
481 pip->clientrereg_resv_subnetto |= 0x80;
482
483 goto done;
484
485 err:
486 smp->status |= IB_SMP_INVALID_FIELD;
487 ret = recv_subn_get_portinfo(smp, ibdev, port);
488
489 done:
490 return ret;
491 }
492
493 static int recv_subn_set_pkeytable(struct ib_smp *smp,
494 struct ib_device *ibdev)
495 {
496 u32 startpx = 32 * (be32_to_cpu(smp->attr_mod) & 0xffff);
497 __be16 *p = (__be16 *) smp->data;
498 u16 *q = (u16 *) smp->data;
499 struct ipath_ibdev *dev = to_idev(ibdev);
500 unsigned i, n = ipath_layer_get_npkeys(dev->dd);
501
502 for (i = 0; i < n; i++)
503 q[i] = be16_to_cpu(p[i]);
504
505 if (startpx != 0 ||
506 ipath_layer_set_pkeys(dev->dd, q) != 0)
507 smp->status |= IB_SMP_INVALID_FIELD;
508
509 return recv_subn_get_pkeytable(smp, ibdev);
510 }
511
512 #define IB_PMA_CLASS_PORT_INFO __constant_htons(0x0001)
513 #define IB_PMA_PORT_SAMPLES_CONTROL __constant_htons(0x0010)
514 #define IB_PMA_PORT_SAMPLES_RESULT __constant_htons(0x0011)
515 #define IB_PMA_PORT_COUNTERS __constant_htons(0x0012)
516 #define IB_PMA_PORT_COUNTERS_EXT __constant_htons(0x001D)
517 #define IB_PMA_PORT_SAMPLES_RESULT_EXT __constant_htons(0x001E)
518
519 struct ib_perf {
520 u8 base_version;
521 u8 mgmt_class;
522 u8 class_version;
523 u8 method;
524 __be16 status;
525 __be16 unused;
526 __be64 tid;
527 __be16 attr_id;
528 __be16 resv;
529 __be32 attr_mod;
530 u8 reserved[40];
531 u8 data[192];
532 } __attribute__ ((packed));
533
534 struct ib_pma_classportinfo {
535 u8 base_version;
536 u8 class_version;
537 __be16 cap_mask;
538 u8 reserved[3];
539 u8 resp_time_value; /* only lower 5 bits */
540 union ib_gid redirect_gid;
541 __be32 redirect_tc_sl_fl; /* 8, 4, 20 bits respectively */
542 __be16 redirect_lid;
543 __be16 redirect_pkey;
544 __be32 redirect_qp; /* only lower 24 bits */
545 __be32 redirect_qkey;
546 union ib_gid trap_gid;
547 __be32 trap_tc_sl_fl; /* 8, 4, 20 bits respectively */
548 __be16 trap_lid;
549 __be16 trap_pkey;
550 __be32 trap_hl_qp; /* 8, 24 bits respectively */
551 __be32 trap_qkey;
552 } __attribute__ ((packed));
553
554 struct ib_pma_portsamplescontrol {
555 u8 opcode;
556 u8 port_select;
557 u8 tick;
558 u8 counter_width; /* only lower 3 bits */
559 __be32 counter_mask0_9; /* 2, 10 * 3, bits */
560 __be16 counter_mask10_14; /* 1, 5 * 3, bits */
561 u8 sample_mechanisms;
562 u8 sample_status; /* only lower 2 bits */
563 __be64 option_mask;
564 __be64 vendor_mask;
565 __be32 sample_start;
566 __be32 sample_interval;
567 __be16 tag;
568 __be16 counter_select[15];
569 } __attribute__ ((packed));
570
571 struct ib_pma_portsamplesresult {
572 __be16 tag;
573 __be16 sample_status; /* only lower 2 bits */
574 __be32 counter[15];
575 } __attribute__ ((packed));
576
577 struct ib_pma_portsamplesresult_ext {
578 __be16 tag;
579 __be16 sample_status; /* only lower 2 bits */
580 __be32 extended_width; /* only upper 2 bits */
581 __be64 counter[15];
582 } __attribute__ ((packed));
583
584 struct ib_pma_portcounters {
585 u8 reserved;
586 u8 port_select;
587 __be16 counter_select;
588 __be16 symbol_error_counter;
589 u8 link_error_recovery_counter;
590 u8 link_downed_counter;
591 __be16 port_rcv_errors;
592 __be16 port_rcv_remphys_errors;
593 __be16 port_rcv_switch_relay_errors;
594 __be16 port_xmit_discards;
595 u8 port_xmit_constraint_errors;
596 u8 port_rcv_constraint_errors;
597 u8 reserved1;
598 u8 lli_ebor_errors; /* 4, 4, bits */
599 __be16 reserved2;
600 __be16 vl15_dropped;
601 __be32 port_xmit_data;
602 __be32 port_rcv_data;
603 __be32 port_xmit_packets;
604 __be32 port_rcv_packets;
605 } __attribute__ ((packed));
606
607 #define IB_PMA_SEL_SYMBOL_ERROR __constant_htons(0x0001)
608 #define IB_PMA_SEL_LINK_ERROR_RECOVERY __constant_htons(0x0002)
609 #define IB_PMA_SEL_LINK_DOWNED __constant_htons(0x0004)
610 #define IB_PMA_SEL_PORT_RCV_ERRORS __constant_htons(0x0008)
611 #define IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS __constant_htons(0x0010)
612 #define IB_PMA_SEL_PORT_XMIT_DISCARDS __constant_htons(0x0040)
613 #define IB_PMA_SEL_PORT_XMIT_DATA __constant_htons(0x1000)
614 #define IB_PMA_SEL_PORT_RCV_DATA __constant_htons(0x2000)
615 #define IB_PMA_SEL_PORT_XMIT_PACKETS __constant_htons(0x4000)
616 #define IB_PMA_SEL_PORT_RCV_PACKETS __constant_htons(0x8000)
617
618 struct ib_pma_portcounters_ext {
619 u8 reserved;
620 u8 port_select;
621 __be16 counter_select;
622 __be32 reserved1;
623 __be64 port_xmit_data;
624 __be64 port_rcv_data;
625 __be64 port_xmit_packets;
626 __be64 port_rcv_packets;
627 __be64 port_unicast_xmit_packets;
628 __be64 port_unicast_rcv_packets;
629 __be64 port_multicast_xmit_packets;
630 __be64 port_multicast_rcv_packets;
631 } __attribute__ ((packed));
632
633 #define IB_PMA_SELX_PORT_XMIT_DATA __constant_htons(0x0001)
634 #define IB_PMA_SELX_PORT_RCV_DATA __constant_htons(0x0002)
635 #define IB_PMA_SELX_PORT_XMIT_PACKETS __constant_htons(0x0004)
636 #define IB_PMA_SELX_PORT_RCV_PACKETS __constant_htons(0x0008)
637 #define IB_PMA_SELX_PORT_UNI_XMIT_PACKETS __constant_htons(0x0010)
638 #define IB_PMA_SELX_PORT_UNI_RCV_PACKETS __constant_htons(0x0020)
639 #define IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS __constant_htons(0x0040)
640 #define IB_PMA_SELX_PORT_MULTI_RCV_PACKETS __constant_htons(0x0080)
641
642 static int recv_pma_get_classportinfo(struct ib_perf *pmp)
643 {
644 struct ib_pma_classportinfo *p =
645 (struct ib_pma_classportinfo *)pmp->data;
646
647 memset(pmp->data, 0, sizeof(pmp->data));
648
649 if (pmp->attr_mod != 0)
650 pmp->status |= IB_SMP_INVALID_FIELD;
651
652 /* Indicate AllPortSelect is valid (only one port anyway) */
653 p->cap_mask = __constant_cpu_to_be16(1 << 8);
654 p->base_version = 1;
655 p->class_version = 1;
656 /*
657 * Expected response time is 4.096 usec. * 2^18 == 1.073741824
658 * sec.
659 */
660 p->resp_time_value = 18;
661
662 return reply((struct ib_smp *) pmp);
663 }
664
665 /*
666 * The PortSamplesControl.CounterMasks field is an array of 3 bit fields
667 * which specify the N'th counter's capabilities. See ch. 16.1.3.2.
668 * We support 5 counters which only count the mandatory quantities.
669 */
670 #define COUNTER_MASK(q, n) (q << ((9 - n) * 3))
671 #define COUNTER_MASK0_9 \
672 __constant_cpu_to_be32(COUNTER_MASK(1, 0) | \
673 COUNTER_MASK(1, 1) | \
674 COUNTER_MASK(1, 2) | \
675 COUNTER_MASK(1, 3) | \
676 COUNTER_MASK(1, 4))
677
678 static int recv_pma_get_portsamplescontrol(struct ib_perf *pmp,
679 struct ib_device *ibdev, u8 port)
680 {
681 struct ib_pma_portsamplescontrol *p =
682 (struct ib_pma_portsamplescontrol *)pmp->data;
683 struct ipath_ibdev *dev = to_idev(ibdev);
684 unsigned long flags;
685 u8 port_select = p->port_select;
686
687 memset(pmp->data, 0, sizeof(pmp->data));
688
689 p->port_select = port_select;
690 if (pmp->attr_mod != 0 ||
691 (port_select != port && port_select != 0xFF))
692 pmp->status |= IB_SMP_INVALID_FIELD;
693 /*
694 * Ticks are 10x the link transfer period which for 2.5Gbs is 4
695 * nsec. 0 == 4 nsec., 1 == 8 nsec., ..., 255 == 1020 nsec. Sample
696 * intervals are counted in ticks. Since we use Linux timers, that
697 * count in jiffies, we can't sample for less than 1000 ticks if HZ
698 * == 1000 (4000 ticks if HZ is 250).
699 */
700 /* XXX This is WRONG. */
701 p->tick = 250; /* 1 usec. */
702 p->counter_width = 4; /* 32 bit counters */
703 p->counter_mask0_9 = COUNTER_MASK0_9;
704 spin_lock_irqsave(&dev->pending_lock, flags);
705 p->sample_status = dev->pma_sample_status;
706 p->sample_start = cpu_to_be32(dev->pma_sample_start);
707 p->sample_interval = cpu_to_be32(dev->pma_sample_interval);
708 p->tag = cpu_to_be16(dev->pma_tag);
709 p->counter_select[0] = dev->pma_counter_select[0];
710 p->counter_select[1] = dev->pma_counter_select[1];
711 p->counter_select[2] = dev->pma_counter_select[2];
712 p->counter_select[3] = dev->pma_counter_select[3];
713 p->counter_select[4] = dev->pma_counter_select[4];
714 spin_unlock_irqrestore(&dev->pending_lock, flags);
715
716 return reply((struct ib_smp *) pmp);
717 }
718
719 static int recv_pma_set_portsamplescontrol(struct ib_perf *pmp,
720 struct ib_device *ibdev, u8 port)
721 {
722 struct ib_pma_portsamplescontrol *p =
723 (struct ib_pma_portsamplescontrol *)pmp->data;
724 struct ipath_ibdev *dev = to_idev(ibdev);
725 unsigned long flags;
726 u32 start;
727 int ret;
728
729 if (pmp->attr_mod != 0 ||
730 (p->port_select != port && p->port_select != 0xFF)) {
731 pmp->status |= IB_SMP_INVALID_FIELD;
732 ret = reply((struct ib_smp *) pmp);
733 goto bail;
734 }
735
736 start = be32_to_cpu(p->sample_start);
737 if (start != 0) {
738 spin_lock_irqsave(&dev->pending_lock, flags);
739 if (dev->pma_sample_status == IB_PMA_SAMPLE_STATUS_DONE) {
740 dev->pma_sample_status =
741 IB_PMA_SAMPLE_STATUS_STARTED;
742 dev->pma_sample_start = start;
743 dev->pma_sample_interval =
744 be32_to_cpu(p->sample_interval);
745 dev->pma_tag = be16_to_cpu(p->tag);
746 if (p->counter_select[0])
747 dev->pma_counter_select[0] =
748 p->counter_select[0];
749 if (p->counter_select[1])
750 dev->pma_counter_select[1] =
751 p->counter_select[1];
752 if (p->counter_select[2])
753 dev->pma_counter_select[2] =
754 p->counter_select[2];
755 if (p->counter_select[3])
756 dev->pma_counter_select[3] =
757 p->counter_select[3];
758 if (p->counter_select[4])
759 dev->pma_counter_select[4] =
760 p->counter_select[4];
761 }
762 spin_unlock_irqrestore(&dev->pending_lock, flags);
763 }
764 ret = recv_pma_get_portsamplescontrol(pmp, ibdev, port);
765
766 bail:
767 return ret;
768 }
769
770 static u64 get_counter(struct ipath_ibdev *dev, __be16 sel)
771 {
772 u64 ret;
773
774 switch (sel) {
775 case IB_PMA_PORT_XMIT_DATA:
776 ret = dev->ipath_sword;
777 break;
778 case IB_PMA_PORT_RCV_DATA:
779 ret = dev->ipath_rword;
780 break;
781 case IB_PMA_PORT_XMIT_PKTS:
782 ret = dev->ipath_spkts;
783 break;
784 case IB_PMA_PORT_RCV_PKTS:
785 ret = dev->ipath_rpkts;
786 break;
787 case IB_PMA_PORT_XMIT_WAIT:
788 ret = dev->ipath_xmit_wait;
789 break;
790 default:
791 ret = 0;
792 }
793
794 return ret;
795 }
796
797 static int recv_pma_get_portsamplesresult(struct ib_perf *pmp,
798 struct ib_device *ibdev)
799 {
800 struct ib_pma_portsamplesresult *p =
801 (struct ib_pma_portsamplesresult *)pmp->data;
802 struct ipath_ibdev *dev = to_idev(ibdev);
803 int i;
804
805 memset(pmp->data, 0, sizeof(pmp->data));
806 p->tag = cpu_to_be16(dev->pma_tag);
807 p->sample_status = cpu_to_be16(dev->pma_sample_status);
808 for (i = 0; i < ARRAY_SIZE(dev->pma_counter_select); i++)
809 p->counter[i] = cpu_to_be32(
810 get_counter(dev, dev->pma_counter_select[i]));
811
812 return reply((struct ib_smp *) pmp);
813 }
814
815 static int recv_pma_get_portsamplesresult_ext(struct ib_perf *pmp,
816 struct ib_device *ibdev)
817 {
818 struct ib_pma_portsamplesresult_ext *p =
819 (struct ib_pma_portsamplesresult_ext *)pmp->data;
820 struct ipath_ibdev *dev = to_idev(ibdev);
821 int i;
822
823 memset(pmp->data, 0, sizeof(pmp->data));
824 p->tag = cpu_to_be16(dev->pma_tag);
825 p->sample_status = cpu_to_be16(dev->pma_sample_status);
826 /* 64 bits */
827 p->extended_width = __constant_cpu_to_be32(0x80000000);
828 for (i = 0; i < ARRAY_SIZE(dev->pma_counter_select); i++)
829 p->counter[i] = cpu_to_be64(
830 get_counter(dev, dev->pma_counter_select[i]));
831
832 return reply((struct ib_smp *) pmp);
833 }
834
835 static int recv_pma_get_portcounters(struct ib_perf *pmp,
836 struct ib_device *ibdev, u8 port)
837 {
838 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
839 pmp->data;
840 struct ipath_ibdev *dev = to_idev(ibdev);
841 struct ipath_layer_counters cntrs;
842 u8 port_select = p->port_select;
843
844 ipath_layer_get_counters(dev->dd, &cntrs);
845
846 /* Adjust counters for any resets done. */
847 cntrs.symbol_error_counter -= dev->n_symbol_error_counter;
848 cntrs.link_error_recovery_counter -=
849 dev->n_link_error_recovery_counter;
850 cntrs.link_downed_counter -= dev->n_link_downed_counter;
851 cntrs.port_rcv_errors += dev->rcv_errors;
852 cntrs.port_rcv_errors -= dev->n_port_rcv_errors;
853 cntrs.port_rcv_remphys_errors -= dev->n_port_rcv_remphys_errors;
854 cntrs.port_xmit_discards -= dev->n_port_xmit_discards;
855 cntrs.port_xmit_data -= dev->n_port_xmit_data;
856 cntrs.port_rcv_data -= dev->n_port_rcv_data;
857 cntrs.port_xmit_packets -= dev->n_port_xmit_packets;
858 cntrs.port_rcv_packets -= dev->n_port_rcv_packets;
859
860 memset(pmp->data, 0, sizeof(pmp->data));
861
862 p->port_select = port_select;
863 if (pmp->attr_mod != 0 ||
864 (port_select != port && port_select != 0xFF))
865 pmp->status |= IB_SMP_INVALID_FIELD;
866
867 if (cntrs.symbol_error_counter > 0xFFFFUL)
868 p->symbol_error_counter = __constant_cpu_to_be16(0xFFFF);
869 else
870 p->symbol_error_counter =
871 cpu_to_be16((u16)cntrs.symbol_error_counter);
872 if (cntrs.link_error_recovery_counter > 0xFFUL)
873 p->link_error_recovery_counter = 0xFF;
874 else
875 p->link_error_recovery_counter =
876 (u8)cntrs.link_error_recovery_counter;
877 if (cntrs.link_downed_counter > 0xFFUL)
878 p->link_downed_counter = 0xFF;
879 else
880 p->link_downed_counter = (u8)cntrs.link_downed_counter;
881 if (cntrs.port_rcv_errors > 0xFFFFUL)
882 p->port_rcv_errors = __constant_cpu_to_be16(0xFFFF);
883 else
884 p->port_rcv_errors =
885 cpu_to_be16((u16) cntrs.port_rcv_errors);
886 if (cntrs.port_rcv_remphys_errors > 0xFFFFUL)
887 p->port_rcv_remphys_errors = __constant_cpu_to_be16(0xFFFF);
888 else
889 p->port_rcv_remphys_errors =
890 cpu_to_be16((u16)cntrs.port_rcv_remphys_errors);
891 if (cntrs.port_xmit_discards > 0xFFFFUL)
892 p->port_xmit_discards = __constant_cpu_to_be16(0xFFFF);
893 else
894 p->port_xmit_discards =
895 cpu_to_be16((u16)cntrs.port_xmit_discards);
896 if (cntrs.port_xmit_data > 0xFFFFFFFFUL)
897 p->port_xmit_data = __constant_cpu_to_be32(0xFFFFFFFF);
898 else
899 p->port_xmit_data = cpu_to_be32((u32)cntrs.port_xmit_data);
900 if (cntrs.port_rcv_data > 0xFFFFFFFFUL)
901 p->port_rcv_data = __constant_cpu_to_be32(0xFFFFFFFF);
902 else
903 p->port_rcv_data = cpu_to_be32((u32)cntrs.port_rcv_data);
904 if (cntrs.port_xmit_packets > 0xFFFFFFFFUL)
905 p->port_xmit_packets = __constant_cpu_to_be32(0xFFFFFFFF);
906 else
907 p->port_xmit_packets =
908 cpu_to_be32((u32)cntrs.port_xmit_packets);
909 if (cntrs.port_rcv_packets > 0xFFFFFFFFUL)
910 p->port_rcv_packets = __constant_cpu_to_be32(0xFFFFFFFF);
911 else
912 p->port_rcv_packets =
913 cpu_to_be32((u32) cntrs.port_rcv_packets);
914
915 return reply((struct ib_smp *) pmp);
916 }
917
918 static int recv_pma_get_portcounters_ext(struct ib_perf *pmp,
919 struct ib_device *ibdev, u8 port)
920 {
921 struct ib_pma_portcounters_ext *p =
922 (struct ib_pma_portcounters_ext *)pmp->data;
923 struct ipath_ibdev *dev = to_idev(ibdev);
924 u64 swords, rwords, spkts, rpkts, xwait;
925 u8 port_select = p->port_select;
926
927 ipath_layer_snapshot_counters(dev->dd, &swords, &rwords, &spkts,
928 &rpkts, &xwait);
929
930 /* Adjust counters for any resets done. */
931 swords -= dev->n_port_xmit_data;
932 rwords -= dev->n_port_rcv_data;
933 spkts -= dev->n_port_xmit_packets;
934 rpkts -= dev->n_port_rcv_packets;
935
936 memset(pmp->data, 0, sizeof(pmp->data));
937
938 p->port_select = port_select;
939 if (pmp->attr_mod != 0 ||
940 (port_select != port && port_select != 0xFF))
941 pmp->status |= IB_SMP_INVALID_FIELD;
942
943 p->port_xmit_data = cpu_to_be64(swords);
944 p->port_rcv_data = cpu_to_be64(rwords);
945 p->port_xmit_packets = cpu_to_be64(spkts);
946 p->port_rcv_packets = cpu_to_be64(rpkts);
947 p->port_unicast_xmit_packets = cpu_to_be64(dev->n_unicast_xmit);
948 p->port_unicast_rcv_packets = cpu_to_be64(dev->n_unicast_rcv);
949 p->port_multicast_xmit_packets = cpu_to_be64(dev->n_multicast_xmit);
950 p->port_multicast_rcv_packets = cpu_to_be64(dev->n_multicast_rcv);
951
952 return reply((struct ib_smp *) pmp);
953 }
954
955 static int recv_pma_set_portcounters(struct ib_perf *pmp,
956 struct ib_device *ibdev, u8 port)
957 {
958 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
959 pmp->data;
960 struct ipath_ibdev *dev = to_idev(ibdev);
961 struct ipath_layer_counters cntrs;
962
963 /*
964 * Since the HW doesn't support clearing counters, we save the
965 * current count and subtract it from future responses.
966 */
967 ipath_layer_get_counters(dev->dd, &cntrs);
968
969 if (p->counter_select & IB_PMA_SEL_SYMBOL_ERROR)
970 dev->n_symbol_error_counter = cntrs.symbol_error_counter;
971
972 if (p->counter_select & IB_PMA_SEL_LINK_ERROR_RECOVERY)
973 dev->n_link_error_recovery_counter =
974 cntrs.link_error_recovery_counter;
975
976 if (p->counter_select & IB_PMA_SEL_LINK_DOWNED)
977 dev->n_link_downed_counter = cntrs.link_downed_counter;
978
979 if (p->counter_select & IB_PMA_SEL_PORT_RCV_ERRORS)
980 dev->n_port_rcv_errors =
981 cntrs.port_rcv_errors + dev->rcv_errors;
982
983 if (p->counter_select & IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS)
984 dev->n_port_rcv_remphys_errors =
985 cntrs.port_rcv_remphys_errors;
986
987 if (p->counter_select & IB_PMA_SEL_PORT_XMIT_DISCARDS)
988 dev->n_port_xmit_discards = cntrs.port_xmit_discards;
989
990 if (p->counter_select & IB_PMA_SEL_PORT_XMIT_DATA)
991 dev->n_port_xmit_data = cntrs.port_xmit_data;
992
993 if (p->counter_select & IB_PMA_SEL_PORT_RCV_DATA)
994 dev->n_port_rcv_data = cntrs.port_rcv_data;
995
996 if (p->counter_select & IB_PMA_SEL_PORT_XMIT_PACKETS)
997 dev->n_port_xmit_packets = cntrs.port_xmit_packets;
998
999 if (p->counter_select & IB_PMA_SEL_PORT_RCV_PACKETS)
1000 dev->n_port_rcv_packets = cntrs.port_rcv_packets;
1001
1002 return recv_pma_get_portcounters(pmp, ibdev, port);
1003 }
1004
1005 static int recv_pma_set_portcounters_ext(struct ib_perf *pmp,
1006 struct ib_device *ibdev, u8 port)
1007 {
1008 struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
1009 pmp->data;
1010 struct ipath_ibdev *dev = to_idev(ibdev);
1011 u64 swords, rwords, spkts, rpkts, xwait;
1012
1013 ipath_layer_snapshot_counters(dev->dd, &swords, &rwords, &spkts,
1014 &rpkts, &xwait);
1015
1016 if (p->counter_select & IB_PMA_SELX_PORT_XMIT_DATA)
1017 dev->n_port_xmit_data = swords;
1018
1019 if (p->counter_select & IB_PMA_SELX_PORT_RCV_DATA)
1020 dev->n_port_rcv_data = rwords;
1021
1022 if (p->counter_select & IB_PMA_SELX_PORT_XMIT_PACKETS)
1023 dev->n_port_xmit_packets = spkts;
1024
1025 if (p->counter_select & IB_PMA_SELX_PORT_RCV_PACKETS)
1026 dev->n_port_rcv_packets = rpkts;
1027
1028 if (p->counter_select & IB_PMA_SELX_PORT_UNI_XMIT_PACKETS)
1029 dev->n_unicast_xmit = 0;
1030
1031 if (p->counter_select & IB_PMA_SELX_PORT_UNI_RCV_PACKETS)
1032 dev->n_unicast_rcv = 0;
1033
1034 if (p->counter_select & IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS)
1035 dev->n_multicast_xmit = 0;
1036
1037 if (p->counter_select & IB_PMA_SELX_PORT_MULTI_RCV_PACKETS)
1038 dev->n_multicast_rcv = 0;
1039
1040 return recv_pma_get_portcounters_ext(pmp, ibdev, port);
1041 }
1042
1043 static int process_subn(struct ib_device *ibdev, int mad_flags,
1044 u8 port_num, struct ib_mad *in_mad,
1045 struct ib_mad *out_mad)
1046 {
1047 struct ib_smp *smp = (struct ib_smp *)out_mad;
1048 struct ipath_ibdev *dev = to_idev(ibdev);
1049 int ret;
1050
1051 *out_mad = *in_mad;
1052 if (smp->class_version != 1) {
1053 smp->status |= IB_SMP_UNSUP_VERSION;
1054 ret = reply(smp);
1055 goto bail;
1056 }
1057
1058 /* Is the mkey in the process of expiring? */
1059 if (dev->mkey_lease_timeout && jiffies >= dev->mkey_lease_timeout) {
1060 /* Clear timeout and mkey protection field. */
1061 dev->mkey_lease_timeout = 0;
1062 dev->mkeyprot_resv_lmc &= 0x3F;
1063 }
1064
1065 /*
1066 * M_Key checking depends on
1067 * Portinfo:M_Key_protect_bits
1068 */
1069 if ((mad_flags & IB_MAD_IGNORE_MKEY) == 0 && dev->mkey != 0 &&
1070 dev->mkey != smp->mkey &&
1071 (smp->method == IB_MGMT_METHOD_SET ||
1072 (smp->method == IB_MGMT_METHOD_GET &&
1073 (dev->mkeyprot_resv_lmc >> 7) != 0))) {
1074 if (dev->mkey_violations != 0xFFFF)
1075 ++dev->mkey_violations;
1076 if (dev->mkey_lease_timeout ||
1077 dev->mkey_lease_period == 0) {
1078 ret = IB_MAD_RESULT_SUCCESS |
1079 IB_MAD_RESULT_CONSUMED;
1080 goto bail;
1081 }
1082 dev->mkey_lease_timeout = jiffies +
1083 dev->mkey_lease_period * HZ;
1084 /* Future: Generate a trap notice. */
1085 ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
1086 goto bail;
1087 } else if (dev->mkey_lease_timeout)
1088 dev->mkey_lease_timeout = 0;
1089
1090 switch (smp->method) {
1091 case IB_MGMT_METHOD_GET:
1092 switch (smp->attr_id) {
1093 case IB_SMP_ATTR_NODE_DESC:
1094 ret = recv_subn_get_nodedescription(smp, ibdev);
1095 goto bail;
1096 case IB_SMP_ATTR_NODE_INFO:
1097 ret = recv_subn_get_nodeinfo(smp, ibdev, port_num);
1098 goto bail;
1099 case IB_SMP_ATTR_GUID_INFO:
1100 ret = recv_subn_get_guidinfo(smp, ibdev);
1101 goto bail;
1102 case IB_SMP_ATTR_PORT_INFO:
1103 ret = recv_subn_get_portinfo(smp, ibdev, port_num);
1104 goto bail;
1105 case IB_SMP_ATTR_PKEY_TABLE:
1106 ret = recv_subn_get_pkeytable(smp, ibdev);
1107 goto bail;
1108 case IB_SMP_ATTR_SM_INFO:
1109 if (dev->port_cap_flags & IB_PORT_SM_DISABLED) {
1110 ret = IB_MAD_RESULT_SUCCESS |
1111 IB_MAD_RESULT_CONSUMED;
1112 goto bail;
1113 }
1114 if (dev->port_cap_flags & IB_PORT_SM) {
1115 ret = IB_MAD_RESULT_SUCCESS;
1116 goto bail;
1117 }
1118 /* FALLTHROUGH */
1119 default:
1120 smp->status |= IB_SMP_UNSUP_METH_ATTR;
1121 ret = reply(smp);
1122 goto bail;
1123 }
1124
1125 case IB_MGMT_METHOD_SET:
1126 switch (smp->attr_id) {
1127 case IB_SMP_ATTR_GUID_INFO:
1128 ret = recv_subn_set_guidinfo(smp, ibdev);
1129 goto bail;
1130 case IB_SMP_ATTR_PORT_INFO:
1131 ret = recv_subn_set_portinfo(smp, ibdev, port_num);
1132 goto bail;
1133 case IB_SMP_ATTR_PKEY_TABLE:
1134 ret = recv_subn_set_pkeytable(smp, ibdev);
1135 goto bail;
1136 case IB_SMP_ATTR_SM_INFO:
1137 if (dev->port_cap_flags & IB_PORT_SM_DISABLED) {
1138 ret = IB_MAD_RESULT_SUCCESS |
1139 IB_MAD_RESULT_CONSUMED;
1140 goto bail;
1141 }
1142 if (dev->port_cap_flags & IB_PORT_SM) {
1143 ret = IB_MAD_RESULT_SUCCESS;
1144 goto bail;
1145 }
1146 /* FALLTHROUGH */
1147 default:
1148 smp->status |= IB_SMP_UNSUP_METH_ATTR;
1149 ret = reply(smp);
1150 goto bail;
1151 }
1152
1153 case IB_MGMT_METHOD_GET_RESP:
1154 /*
1155 * The ib_mad module will call us to process responses
1156 * before checking for other consumers.
1157 * Just tell the caller to process it normally.
1158 */
1159 ret = IB_MAD_RESULT_FAILURE;
1160 goto bail;
1161 default:
1162 smp->status |= IB_SMP_UNSUP_METHOD;
1163 ret = reply(smp);
1164 }
1165
1166 bail:
1167 return ret;
1168 }
1169
1170 static int process_perf(struct ib_device *ibdev, u8 port_num,
1171 struct ib_mad *in_mad,
1172 struct ib_mad *out_mad)
1173 {
1174 struct ib_perf *pmp = (struct ib_perf *)out_mad;
1175 int ret;
1176
1177 *out_mad = *in_mad;
1178 if (pmp->class_version != 1) {
1179 pmp->status |= IB_SMP_UNSUP_VERSION;
1180 ret = reply((struct ib_smp *) pmp);
1181 goto bail;
1182 }
1183
1184 switch (pmp->method) {
1185 case IB_MGMT_METHOD_GET:
1186 switch (pmp->attr_id) {
1187 case IB_PMA_CLASS_PORT_INFO:
1188 ret = recv_pma_get_classportinfo(pmp);
1189 goto bail;
1190 case IB_PMA_PORT_SAMPLES_CONTROL:
1191 ret = recv_pma_get_portsamplescontrol(pmp, ibdev,
1192 port_num);
1193 goto bail;
1194 case IB_PMA_PORT_SAMPLES_RESULT:
1195 ret = recv_pma_get_portsamplesresult(pmp, ibdev);
1196 goto bail;
1197 case IB_PMA_PORT_SAMPLES_RESULT_EXT:
1198 ret = recv_pma_get_portsamplesresult_ext(pmp,
1199 ibdev);
1200 goto bail;
1201 case IB_PMA_PORT_COUNTERS:
1202 ret = recv_pma_get_portcounters(pmp, ibdev,
1203 port_num);
1204 goto bail;
1205 case IB_PMA_PORT_COUNTERS_EXT:
1206 ret = recv_pma_get_portcounters_ext(pmp, ibdev,
1207 port_num);
1208 goto bail;
1209 default:
1210 pmp->status |= IB_SMP_UNSUP_METH_ATTR;
1211 ret = reply((struct ib_smp *) pmp);
1212 goto bail;
1213 }
1214
1215 case IB_MGMT_METHOD_SET:
1216 switch (pmp->attr_id) {
1217 case IB_PMA_PORT_SAMPLES_CONTROL:
1218 ret = recv_pma_set_portsamplescontrol(pmp, ibdev,
1219 port_num);
1220 goto bail;
1221 case IB_PMA_PORT_COUNTERS:
1222 ret = recv_pma_set_portcounters(pmp, ibdev,
1223 port_num);
1224 goto bail;
1225 case IB_PMA_PORT_COUNTERS_EXT:
1226 ret = recv_pma_set_portcounters_ext(pmp, ibdev,
1227 port_num);
1228 goto bail;
1229 default:
1230 pmp->status |= IB_SMP_UNSUP_METH_ATTR;
1231 ret = reply((struct ib_smp *) pmp);
1232 goto bail;
1233 }
1234
1235 case IB_MGMT_METHOD_GET_RESP:
1236 /*
1237 * The ib_mad module will call us to process responses
1238 * before checking for other consumers.
1239 * Just tell the caller to process it normally.
1240 */
1241 ret = IB_MAD_RESULT_FAILURE;
1242 goto bail;
1243 default:
1244 pmp->status |= IB_SMP_UNSUP_METHOD;
1245 ret = reply((struct ib_smp *) pmp);
1246 }
1247
1248 bail:
1249 return ret;
1250 }
1251
1252 /**
1253 * ipath_process_mad - process an incoming MAD packet
1254 * @ibdev: the infiniband device this packet came in on
1255 * @mad_flags: MAD flags
1256 * @port_num: the port number this packet came in on
1257 * @in_wc: the work completion entry for this packet
1258 * @in_grh: the global route header for this packet
1259 * @in_mad: the incoming MAD
1260 * @out_mad: any outgoing MAD reply
1261 *
1262 * Returns IB_MAD_RESULT_SUCCESS if this is a MAD that we are not
1263 * interested in processing.
1264 *
1265 * Note that the verbs framework has already done the MAD sanity checks,
1266 * and hop count/pointer updating for IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE
1267 * MADs.
1268 *
1269 * This is called by the ib_mad module.
1270 */
1271 int ipath_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
1272 struct ib_wc *in_wc, struct ib_grh *in_grh,
1273 struct ib_mad *in_mad, struct ib_mad *out_mad)
1274 {
1275 struct ipath_ibdev *dev = to_idev(ibdev);
1276 int ret;
1277
1278 /*
1279 * Snapshot current HW counters to "clear" them.
1280 * This should be done when the driver is loaded except that for
1281 * some reason we get a zillion errors when brining up the link.
1282 */
1283 if (dev->rcv_errors == 0) {
1284 struct ipath_layer_counters cntrs;
1285
1286 ipath_layer_get_counters(to_idev(ibdev)->dd, &cntrs);
1287 dev->rcv_errors++;
1288 dev->n_symbol_error_counter = cntrs.symbol_error_counter;
1289 dev->n_link_error_recovery_counter =
1290 cntrs.link_error_recovery_counter;
1291 dev->n_link_downed_counter = cntrs.link_downed_counter;
1292 dev->n_port_rcv_errors = cntrs.port_rcv_errors + 1;
1293 dev->n_port_rcv_remphys_errors =
1294 cntrs.port_rcv_remphys_errors;
1295 dev->n_port_xmit_discards = cntrs.port_xmit_discards;
1296 dev->n_port_xmit_data = cntrs.port_xmit_data;
1297 dev->n_port_rcv_data = cntrs.port_rcv_data;
1298 dev->n_port_xmit_packets = cntrs.port_xmit_packets;
1299 dev->n_port_rcv_packets = cntrs.port_rcv_packets;
1300 }
1301 switch (in_mad->mad_hdr.mgmt_class) {
1302 case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
1303 case IB_MGMT_CLASS_SUBN_LID_ROUTED:
1304 ret = process_subn(ibdev, mad_flags, port_num,
1305 in_mad, out_mad);
1306 goto bail;
1307 case IB_MGMT_CLASS_PERF_MGMT:
1308 ret = process_perf(ibdev, port_num, in_mad, out_mad);
1309 goto bail;
1310 default:
1311 ret = IB_MAD_RESULT_SUCCESS;
1312 }
1313
1314 bail:
1315 return ret;
1316 }
Linux kernel - Deliverables
This page took 0.161279 seconds and 4 git commands to generate.