1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
3 *
4 * Copyright (c) 2004, 2011 Intel Corporation. All rights reserved.
5 * Copyright (c) 2004 Topspin Corporation. All rights reserved.
6 * Copyright (c) 2004 Voltaire Corporation. All rights reserved.
7 *
8 * This software is available to you under a choice of one of two
9 * licenses. You may choose to be licensed under the terms of the GNU
10 * General Public License (GPL) Version 2, available from the file
11 * COPYING the madirectory of this source tree, or the
12 * OpenIB.org BSD license below:
13 *
14 * Redistribution and use source and binary forms, with or
15 * withmodification, are permitted provided that the following
16 * conditions are met:
17 *
18 * - Redistributions of source code must retathe above
19 * copyright notice, this list of conditions and the following
20 * disclaimer.
21 *
22 * - Redistributions binary form must reproduce the above
23 * copyright notice, this list of conditions and the following
24 * disclaimer the documentation and/or other materials
25 * provided with the distribution.
26 *
27 * THE SOFTWARE IS PROVIDED "AS IS", WITHWARRANTY OF ANY KIND,
28 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
29 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
30 * NONINFRINGEMENT. NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
31 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER AN
32 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OF OR IN
33 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS THE
34 * SOFTWARE.
35 *
36 * $FreeBSD: stable/12/sys/ofed/drivers/infiniband/core/cm_msgs.h 330490 2018-03-05 11:49:45Z hselasky $
37 */
38
39 #if !defined(CM_MSGS_H)
40 #define CM_MSGS_H
41
42 #include <rdma/ib_mad.h>
43 #include <rdma/ib_cm.h>
44
45 /*
46 * Parameters to routines below should be in network-byte order, and values
47 * are returned in network-byte order.
48 */
49
50 #define IB_CM_CLASS_VERSION 2 /* IB specification 1.2 */
51
52 enum cm_msg_sequence {
53 CM_MSG_SEQUENCE_REQ,
54 CM_MSG_SEQUENCE_LAP,
55 CM_MSG_SEQUENCE_DREQ,
56 CM_MSG_SEQUENCE_SIDR
57 };
58
59 struct cm_req_msg {
60 struct ib_mad_hdr hdr;
61
62 __be32 local_comm_id;
63 __be32 rsvd4;
64 __be64 service_id;
65 __be64 local_ca_guid;
66 __be32 rsvd24;
67 __be32 local_qkey;
68 /* local QPN:24, responder resources:8 */
69 __be32 offset32;
70 /* local EECN:24, initiator depth:8 */
71 __be32 offset36;
72 /*
73 * remote EECN:24, remote CM response timeout:5,
74 * transport service type:2, end-to-end flow control:1
75 */
76 __be32 offset40;
77 /* starting PSN:24, local CM response timeout:5, retry count:3 */
78 __be32 offset44;
79 __be16 pkey;
80 /* path MTU:4, RDC exists:1, RNR retry count:3. */
81 u8 offset50;
82 /* max CM Retries:4, SRQ:1, extended transport type:3 */
83 u8 offset51;
84
85 __be16 primary_local_lid;
86 __be16 primary_remote_lid;
87 union ib_gid primary_local_gid;
88 union ib_gid primary_remote_gid;
89 /* flow label:20, rsvd:6, packet rate:6 */
90 __be32 primary_offset88;
91 u8 primary_traffic_class;
92 u8 primary_hop_limit;
93 /* SL:4, subnet local:1, rsvd:3 */
94 u8 primary_offset94;
95 /* local ACK timeout:5, rsvd:3 */
96 u8 primary_offset95;
97
98 __be16 alt_local_lid;
99 __be16 alt_remote_lid;
100 union ib_gid alt_local_gid;
101 union ib_gid alt_remote_gid;
102 /* flow label:20, rsvd:6, packet rate:6 */
103 __be32 alt_offset132;
104 u8 alt_traffic_class;
105 u8 alt_hop_limit;
106 /* SL:4, subnet local:1, rsvd:3 */
107 u8 alt_offset138;
108 /* local ACK timeout:5, rsvd:3 */
109 u8 alt_offset139;
110
111 u32 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE / sizeof(u32)];
112
113 } __attribute__ ((packed));
114
cm_req_get_local_qpn(struct cm_req_msg * req_msg)115 static inline __be32 cm_req_get_local_qpn(struct cm_req_msg *req_msg)
116 {
117 return cpu_to_be32(be32_to_cpu(req_msg->offset32) >> 8);
118 }
119
cm_req_set_local_qpn(struct cm_req_msg * req_msg,__be32 qpn)120 static inline void cm_req_set_local_qpn(struct cm_req_msg *req_msg, __be32 qpn)
121 {
122 req_msg->offset32 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
123 (be32_to_cpu(req_msg->offset32) &
124 0x000000FF));
125 }
126
cm_req_get_resp_res(struct cm_req_msg * req_msg)127 static inline u8 cm_req_get_resp_res(struct cm_req_msg *req_msg)
128 {
129 return (u8) be32_to_cpu(req_msg->offset32);
130 }
131
cm_req_set_resp_res(struct cm_req_msg * req_msg,u8 resp_res)132 static inline void cm_req_set_resp_res(struct cm_req_msg *req_msg, u8 resp_res)
133 {
134 req_msg->offset32 = cpu_to_be32(resp_res |
135 (be32_to_cpu(req_msg->offset32) &
136 0xFFFFFF00));
137 }
138
cm_req_get_init_depth(struct cm_req_msg * req_msg)139 static inline u8 cm_req_get_init_depth(struct cm_req_msg *req_msg)
140 {
141 return (u8) be32_to_cpu(req_msg->offset36);
142 }
143
cm_req_set_init_depth(struct cm_req_msg * req_msg,u8 init_depth)144 static inline void cm_req_set_init_depth(struct cm_req_msg *req_msg,
145 u8 init_depth)
146 {
147 req_msg->offset36 = cpu_to_be32(init_depth |
148 (be32_to_cpu(req_msg->offset36) &
149 0xFFFFFF00));
150 }
151
cm_req_get_remote_resp_timeout(struct cm_req_msg * req_msg)152 static inline u8 cm_req_get_remote_resp_timeout(struct cm_req_msg *req_msg)
153 {
154 return (u8) ((be32_to_cpu(req_msg->offset40) & 0xF8) >> 3);
155 }
156
cm_req_set_remote_resp_timeout(struct cm_req_msg * req_msg,u8 resp_timeout)157 static inline void cm_req_set_remote_resp_timeout(struct cm_req_msg *req_msg,
158 u8 resp_timeout)
159 {
160 req_msg->offset40 = cpu_to_be32((resp_timeout << 3) |
161 (be32_to_cpu(req_msg->offset40) &
162 0xFFFFFF07));
163 }
164
cm_req_get_qp_type(struct cm_req_msg * req_msg)165 static inline enum ib_qp_type cm_req_get_qp_type(struct cm_req_msg *req_msg)
166 {
167 u8 transport_type = (u8) (be32_to_cpu(req_msg->offset40) & 0x06) >> 1;
168 switch(transport_type) {
169 case 0: return IB_QPT_RC;
170 case 1: return IB_QPT_UC;
171 case 3:
172 switch (req_msg->offset51 & 0x7) {
173 case 1: return IB_QPT_XRC_TGT;
174 default: return 0;
175 }
176 default: return 0;
177 }
178 }
179
cm_req_set_qp_type(struct cm_req_msg * req_msg,enum ib_qp_type qp_type)180 static inline void cm_req_set_qp_type(struct cm_req_msg *req_msg,
181 enum ib_qp_type qp_type)
182 {
183 switch(qp_type) {
184 case IB_QPT_UC:
185 req_msg->offset40 = cpu_to_be32((be32_to_cpu(
186 req_msg->offset40) &
187 0xFFFFFFF9) | 0x2);
188 break;
189 case IB_QPT_XRC_INI:
190 req_msg->offset40 = cpu_to_be32((be32_to_cpu(
191 req_msg->offset40) &
192 0xFFFFFFF9) | 0x6);
193 req_msg->offset51 = (req_msg->offset51 & 0xF8) | 1;
194 break;
195 default:
196 req_msg->offset40 = cpu_to_be32(be32_to_cpu(
197 req_msg->offset40) &
198 0xFFFFFFF9);
199 }
200 }
201
cm_req_get_flow_ctrl(struct cm_req_msg * req_msg)202 static inline u8 cm_req_get_flow_ctrl(struct cm_req_msg *req_msg)
203 {
204 return be32_to_cpu(req_msg->offset40) & 0x1;
205 }
206
cm_req_set_flow_ctrl(struct cm_req_msg * req_msg,u8 flow_ctrl)207 static inline void cm_req_set_flow_ctrl(struct cm_req_msg *req_msg,
208 u8 flow_ctrl)
209 {
210 req_msg->offset40 = cpu_to_be32((flow_ctrl & 0x1) |
211 (be32_to_cpu(req_msg->offset40) &
212 0xFFFFFFFE));
213 }
214
cm_req_get_starting_psn(struct cm_req_msg * req_msg)215 static inline __be32 cm_req_get_starting_psn(struct cm_req_msg *req_msg)
216 {
217 return cpu_to_be32(be32_to_cpu(req_msg->offset44) >> 8);
218 }
219
cm_req_set_starting_psn(struct cm_req_msg * req_msg,__be32 starting_psn)220 static inline void cm_req_set_starting_psn(struct cm_req_msg *req_msg,
221 __be32 starting_psn)
222 {
223 req_msg->offset44 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) |
224 (be32_to_cpu(req_msg->offset44) & 0x000000FF));
225 }
226
cm_req_get_local_resp_timeout(struct cm_req_msg * req_msg)227 static inline u8 cm_req_get_local_resp_timeout(struct cm_req_msg *req_msg)
228 {
229 return (u8) ((be32_to_cpu(req_msg->offset44) & 0xF8) >> 3);
230 }
231
cm_req_set_local_resp_timeout(struct cm_req_msg * req_msg,u8 resp_timeout)232 static inline void cm_req_set_local_resp_timeout(struct cm_req_msg *req_msg,
233 u8 resp_timeout)
234 {
235 req_msg->offset44 = cpu_to_be32((resp_timeout << 3) |
236 (be32_to_cpu(req_msg->offset44) & 0xFFFFFF07));
237 }
238
cm_req_get_retry_count(struct cm_req_msg * req_msg)239 static inline u8 cm_req_get_retry_count(struct cm_req_msg *req_msg)
240 {
241 return (u8) (be32_to_cpu(req_msg->offset44) & 0x7);
242 }
243
cm_req_set_retry_count(struct cm_req_msg * req_msg,u8 retry_count)244 static inline void cm_req_set_retry_count(struct cm_req_msg *req_msg,
245 u8 retry_count)
246 {
247 req_msg->offset44 = cpu_to_be32((retry_count & 0x7) |
248 (be32_to_cpu(req_msg->offset44) & 0xFFFFFFF8));
249 }
250
cm_req_get_path_mtu(struct cm_req_msg * req_msg)251 static inline u8 cm_req_get_path_mtu(struct cm_req_msg *req_msg)
252 {
253 return req_msg->offset50 >> 4;
254 }
255
cm_req_set_path_mtu(struct cm_req_msg * req_msg,u8 path_mtu)256 static inline void cm_req_set_path_mtu(struct cm_req_msg *req_msg, u8 path_mtu)
257 {
258 req_msg->offset50 = (u8) ((req_msg->offset50 & 0xF) | (path_mtu << 4));
259 }
260
cm_req_get_rnr_retry_count(struct cm_req_msg * req_msg)261 static inline u8 cm_req_get_rnr_retry_count(struct cm_req_msg *req_msg)
262 {
263 return req_msg->offset50 & 0x7;
264 }
265
cm_req_set_rnr_retry_count(struct cm_req_msg * req_msg,u8 rnr_retry_count)266 static inline void cm_req_set_rnr_retry_count(struct cm_req_msg *req_msg,
267 u8 rnr_retry_count)
268 {
269 req_msg->offset50 = (u8) ((req_msg->offset50 & 0xF8) |
270 (rnr_retry_count & 0x7));
271 }
272
cm_req_get_max_cm_retries(struct cm_req_msg * req_msg)273 static inline u8 cm_req_get_max_cm_retries(struct cm_req_msg *req_msg)
274 {
275 return req_msg->offset51 >> 4;
276 }
277
cm_req_set_max_cm_retries(struct cm_req_msg * req_msg,u8 retries)278 static inline void cm_req_set_max_cm_retries(struct cm_req_msg *req_msg,
279 u8 retries)
280 {
281 req_msg->offset51 = (u8) ((req_msg->offset51 & 0xF) | (retries << 4));
282 }
283
cm_req_get_srq(struct cm_req_msg * req_msg)284 static inline u8 cm_req_get_srq(struct cm_req_msg *req_msg)
285 {
286 return (req_msg->offset51 & 0x8) >> 3;
287 }
288
cm_req_set_srq(struct cm_req_msg * req_msg,u8 srq)289 static inline void cm_req_set_srq(struct cm_req_msg *req_msg, u8 srq)
290 {
291 req_msg->offset51 = (u8) ((req_msg->offset51 & 0xF7) |
292 ((srq & 0x1) << 3));
293 }
294
cm_req_get_primary_flow_label(struct cm_req_msg * req_msg)295 static inline __be32 cm_req_get_primary_flow_label(struct cm_req_msg *req_msg)
296 {
297 return cpu_to_be32(be32_to_cpu(req_msg->primary_offset88) >> 12);
298 }
299
cm_req_set_primary_flow_label(struct cm_req_msg * req_msg,__be32 flow_label)300 static inline void cm_req_set_primary_flow_label(struct cm_req_msg *req_msg,
301 __be32 flow_label)
302 {
303 req_msg->primary_offset88 = cpu_to_be32(
304 (be32_to_cpu(req_msg->primary_offset88) &
305 0x00000FFF) |
306 (be32_to_cpu(flow_label) << 12));
307 }
308
cm_req_get_primary_packet_rate(struct cm_req_msg * req_msg)309 static inline u8 cm_req_get_primary_packet_rate(struct cm_req_msg *req_msg)
310 {
311 return (u8) (be32_to_cpu(req_msg->primary_offset88) & 0x3F);
312 }
313
cm_req_set_primary_packet_rate(struct cm_req_msg * req_msg,u8 rate)314 static inline void cm_req_set_primary_packet_rate(struct cm_req_msg *req_msg,
315 u8 rate)
316 {
317 req_msg->primary_offset88 = cpu_to_be32(
318 (be32_to_cpu(req_msg->primary_offset88) &
319 0xFFFFFFC0) | (rate & 0x3F));
320 }
321
cm_req_get_primary_sl(struct cm_req_msg * req_msg)322 static inline u8 cm_req_get_primary_sl(struct cm_req_msg *req_msg)
323 {
324 return (u8) (req_msg->primary_offset94 >> 4);
325 }
326
cm_req_set_primary_sl(struct cm_req_msg * req_msg,u8 sl)327 static inline void cm_req_set_primary_sl(struct cm_req_msg *req_msg, u8 sl)
328 {
329 req_msg->primary_offset94 = (u8) ((req_msg->primary_offset94 & 0x0F) |
330 (sl << 4));
331 }
332
cm_req_get_primary_subnet_local(struct cm_req_msg * req_msg)333 static inline u8 cm_req_get_primary_subnet_local(struct cm_req_msg *req_msg)
334 {
335 return (u8) ((req_msg->primary_offset94 & 0x08) >> 3);
336 }
337
cm_req_set_primary_subnet_local(struct cm_req_msg * req_msg,u8 subnet_local)338 static inline void cm_req_set_primary_subnet_local(struct cm_req_msg *req_msg,
339 u8 subnet_local)
340 {
341 req_msg->primary_offset94 = (u8) ((req_msg->primary_offset94 & 0xF7) |
342 ((subnet_local & 0x1) << 3));
343 }
344
cm_req_get_primary_local_ack_timeout(struct cm_req_msg * req_msg)345 static inline u8 cm_req_get_primary_local_ack_timeout(struct cm_req_msg *req_msg)
346 {
347 return (u8) (req_msg->primary_offset95 >> 3);
348 }
349
cm_req_set_primary_local_ack_timeout(struct cm_req_msg * req_msg,u8 local_ack_timeout)350 static inline void cm_req_set_primary_local_ack_timeout(struct cm_req_msg *req_msg,
351 u8 local_ack_timeout)
352 {
353 req_msg->primary_offset95 = (u8) ((req_msg->primary_offset95 & 0x07) |
354 (local_ack_timeout << 3));
355 }
356
cm_req_get_alt_flow_label(struct cm_req_msg * req_msg)357 static inline __be32 cm_req_get_alt_flow_label(struct cm_req_msg *req_msg)
358 {
359 return cpu_to_be32(be32_to_cpu(req_msg->alt_offset132) >> 12);
360 }
361
cm_req_set_alt_flow_label(struct cm_req_msg * req_msg,__be32 flow_label)362 static inline void cm_req_set_alt_flow_label(struct cm_req_msg *req_msg,
363 __be32 flow_label)
364 {
365 req_msg->alt_offset132 = cpu_to_be32(
366 (be32_to_cpu(req_msg->alt_offset132) &
367 0x00000FFF) |
368 (be32_to_cpu(flow_label) << 12));
369 }
370
cm_req_get_alt_packet_rate(struct cm_req_msg * req_msg)371 static inline u8 cm_req_get_alt_packet_rate(struct cm_req_msg *req_msg)
372 {
373 return (u8) (be32_to_cpu(req_msg->alt_offset132) & 0x3F);
374 }
375
cm_req_set_alt_packet_rate(struct cm_req_msg * req_msg,u8 rate)376 static inline void cm_req_set_alt_packet_rate(struct cm_req_msg *req_msg,
377 u8 rate)
378 {
379 req_msg->alt_offset132 = cpu_to_be32(
380 (be32_to_cpu(req_msg->alt_offset132) &
381 0xFFFFFFC0) | (rate & 0x3F));
382 }
383
cm_req_get_alt_sl(struct cm_req_msg * req_msg)384 static inline u8 cm_req_get_alt_sl(struct cm_req_msg *req_msg)
385 {
386 return (u8) (req_msg->alt_offset138 >> 4);
387 }
388
cm_req_set_alt_sl(struct cm_req_msg * req_msg,u8 sl)389 static inline void cm_req_set_alt_sl(struct cm_req_msg *req_msg, u8 sl)
390 {
391 req_msg->alt_offset138 = (u8) ((req_msg->alt_offset138 & 0x0F) |
392 (sl << 4));
393 }
394
cm_req_get_alt_subnet_local(struct cm_req_msg * req_msg)395 static inline u8 cm_req_get_alt_subnet_local(struct cm_req_msg *req_msg)
396 {
397 return (u8) ((req_msg->alt_offset138 & 0x08) >> 3);
398 }
399
cm_req_set_alt_subnet_local(struct cm_req_msg * req_msg,u8 subnet_local)400 static inline void cm_req_set_alt_subnet_local(struct cm_req_msg *req_msg,
401 u8 subnet_local)
402 {
403 req_msg->alt_offset138 = (u8) ((req_msg->alt_offset138 & 0xF7) |
404 ((subnet_local & 0x1) << 3));
405 }
406
cm_req_get_alt_local_ack_timeout(struct cm_req_msg * req_msg)407 static inline u8 cm_req_get_alt_local_ack_timeout(struct cm_req_msg *req_msg)
408 {
409 return (u8) (req_msg->alt_offset139 >> 3);
410 }
411
cm_req_set_alt_local_ack_timeout(struct cm_req_msg * req_msg,u8 local_ack_timeout)412 static inline void cm_req_set_alt_local_ack_timeout(struct cm_req_msg *req_msg,
413 u8 local_ack_timeout)
414 {
415 req_msg->alt_offset139 = (u8) ((req_msg->alt_offset139 & 0x07) |
416 (local_ack_timeout << 3));
417 }
418
419 /* Message REJected or MRAed */
420 enum cm_msg_response {
421 CM_MSG_RESPONSE_REQ = 0x0,
422 CM_MSG_RESPONSE_REP = 0x1,
423 CM_MSG_RESPONSE_OTHER = 0x2
424 };
425
426 struct cm_mra_msg {
427 struct ib_mad_hdr hdr;
428
429 __be32 local_comm_id;
430 __be32 remote_comm_id;
431 /* message MRAed:2, rsvd:6 */
432 u8 offset8;
433 /* service timeout:5, rsvd:3 */
434 u8 offset9;
435
436 u8 private_data[IB_CM_MRA_PRIVATE_DATA_SIZE];
437
438 } __attribute__ ((packed));
439
cm_mra_get_msg_mraed(struct cm_mra_msg * mra_msg)440 static inline u8 cm_mra_get_msg_mraed(struct cm_mra_msg *mra_msg)
441 {
442 return (u8) (mra_msg->offset8 >> 6);
443 }
444
cm_mra_set_msg_mraed(struct cm_mra_msg * mra_msg,u8 msg)445 static inline void cm_mra_set_msg_mraed(struct cm_mra_msg *mra_msg, u8 msg)
446 {
447 mra_msg->offset8 = (u8) ((mra_msg->offset8 & 0x3F) | (msg << 6));
448 }
449
cm_mra_get_service_timeout(struct cm_mra_msg * mra_msg)450 static inline u8 cm_mra_get_service_timeout(struct cm_mra_msg *mra_msg)
451 {
452 return (u8) (mra_msg->offset9 >> 3);
453 }
454
cm_mra_set_service_timeout(struct cm_mra_msg * mra_msg,u8 service_timeout)455 static inline void cm_mra_set_service_timeout(struct cm_mra_msg *mra_msg,
456 u8 service_timeout)
457 {
458 mra_msg->offset9 = (u8) ((mra_msg->offset9 & 0x07) |
459 (service_timeout << 3));
460 }
461
462 struct cm_rej_msg {
463 struct ib_mad_hdr hdr;
464
465 __be32 local_comm_id;
466 __be32 remote_comm_id;
467 /* message REJected:2, rsvd:6 */
468 u8 offset8;
469 /* reject info length:7, rsvd:1. */
470 u8 offset9;
471 __be16 reason;
472 u8 ari[IB_CM_REJ_ARI_LENGTH];
473
474 u8 private_data[IB_CM_REJ_PRIVATE_DATA_SIZE];
475
476 } __attribute__ ((packed));
477
cm_rej_get_msg_rejected(struct cm_rej_msg * rej_msg)478 static inline u8 cm_rej_get_msg_rejected(struct cm_rej_msg *rej_msg)
479 {
480 return (u8) (rej_msg->offset8 >> 6);
481 }
482
cm_rej_set_msg_rejected(struct cm_rej_msg * rej_msg,u8 msg)483 static inline void cm_rej_set_msg_rejected(struct cm_rej_msg *rej_msg, u8 msg)
484 {
485 rej_msg->offset8 = (u8) ((rej_msg->offset8 & 0x3F) | (msg << 6));
486 }
487
cm_rej_get_reject_info_len(struct cm_rej_msg * rej_msg)488 static inline u8 cm_rej_get_reject_info_len(struct cm_rej_msg *rej_msg)
489 {
490 return (u8) (rej_msg->offset9 >> 1);
491 }
492
cm_rej_set_reject_info_len(struct cm_rej_msg * rej_msg,u8 len)493 static inline void cm_rej_set_reject_info_len(struct cm_rej_msg *rej_msg,
494 u8 len)
495 {
496 rej_msg->offset9 = (u8) ((rej_msg->offset9 & 0x1) | (len << 1));
497 }
498
499 struct cm_rep_msg {
500 struct ib_mad_hdr hdr;
501
502 __be32 local_comm_id;
503 __be32 remote_comm_id;
504 __be32 local_qkey;
505 /* local QPN:24, rsvd:8 */
506 __be32 offset12;
507 /* local EECN:24, rsvd:8 */
508 __be32 offset16;
509 /* starting PSN:24 rsvd:8 */
510 __be32 offset20;
511 u8 resp_resources;
512 u8 initiator_depth;
513 /* target ACK delay:5, failover accepted:2, end-to-end flow control:1 */
514 u8 offset26;
515 /* RNR retry count:3, SRQ:1, rsvd:5 */
516 u8 offset27;
517 __be64 local_ca_guid;
518
519 u8 private_data[IB_CM_REP_PRIVATE_DATA_SIZE];
520
521 } __attribute__ ((packed));
522
cm_rep_get_local_qpn(struct cm_rep_msg * rep_msg)523 static inline __be32 cm_rep_get_local_qpn(struct cm_rep_msg *rep_msg)
524 {
525 return cpu_to_be32(be32_to_cpu(rep_msg->offset12) >> 8);
526 }
527
cm_rep_set_local_qpn(struct cm_rep_msg * rep_msg,__be32 qpn)528 static inline void cm_rep_set_local_qpn(struct cm_rep_msg *rep_msg, __be32 qpn)
529 {
530 rep_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
531 (be32_to_cpu(rep_msg->offset12) & 0x000000FF));
532 }
533
cm_rep_get_local_eecn(struct cm_rep_msg * rep_msg)534 static inline __be32 cm_rep_get_local_eecn(struct cm_rep_msg *rep_msg)
535 {
536 return cpu_to_be32(be32_to_cpu(rep_msg->offset16) >> 8);
537 }
538
cm_rep_set_local_eecn(struct cm_rep_msg * rep_msg,__be32 eecn)539 static inline void cm_rep_set_local_eecn(struct cm_rep_msg *rep_msg, __be32 eecn)
540 {
541 rep_msg->offset16 = cpu_to_be32((be32_to_cpu(eecn) << 8) |
542 (be32_to_cpu(rep_msg->offset16) & 0x000000FF));
543 }
544
cm_rep_get_qpn(struct cm_rep_msg * rep_msg,enum ib_qp_type qp_type)545 static inline __be32 cm_rep_get_qpn(struct cm_rep_msg *rep_msg, enum ib_qp_type qp_type)
546 {
547 return (qp_type == IB_QPT_XRC_INI) ?
548 cm_rep_get_local_eecn(rep_msg) : cm_rep_get_local_qpn(rep_msg);
549 }
550
cm_rep_get_starting_psn(struct cm_rep_msg * rep_msg)551 static inline __be32 cm_rep_get_starting_psn(struct cm_rep_msg *rep_msg)
552 {
553 return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8);
554 }
555
cm_rep_set_starting_psn(struct cm_rep_msg * rep_msg,__be32 starting_psn)556 static inline void cm_rep_set_starting_psn(struct cm_rep_msg *rep_msg,
557 __be32 starting_psn)
558 {
559 rep_msg->offset20 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) |
560 (be32_to_cpu(rep_msg->offset20) & 0x000000FF));
561 }
562
cm_rep_get_target_ack_delay(struct cm_rep_msg * rep_msg)563 static inline u8 cm_rep_get_target_ack_delay(struct cm_rep_msg *rep_msg)
564 {
565 return (u8) (rep_msg->offset26 >> 3);
566 }
567
cm_rep_set_target_ack_delay(struct cm_rep_msg * rep_msg,u8 target_ack_delay)568 static inline void cm_rep_set_target_ack_delay(struct cm_rep_msg *rep_msg,
569 u8 target_ack_delay)
570 {
571 rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0x07) |
572 (target_ack_delay << 3));
573 }
574
cm_rep_get_failover(struct cm_rep_msg * rep_msg)575 static inline u8 cm_rep_get_failover(struct cm_rep_msg *rep_msg)
576 {
577 return (u8) ((rep_msg->offset26 & 0x06) >> 1);
578 }
579
cm_rep_set_failover(struct cm_rep_msg * rep_msg,u8 failover)580 static inline void cm_rep_set_failover(struct cm_rep_msg *rep_msg, u8 failover)
581 {
582 rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xF9) |
583 ((failover & 0x3) << 1));
584 }
585
cm_rep_get_flow_ctrl(struct cm_rep_msg * rep_msg)586 static inline u8 cm_rep_get_flow_ctrl(struct cm_rep_msg *rep_msg)
587 {
588 return (u8) (rep_msg->offset26 & 0x01);
589 }
590
cm_rep_set_flow_ctrl(struct cm_rep_msg * rep_msg,u8 flow_ctrl)591 static inline void cm_rep_set_flow_ctrl(struct cm_rep_msg *rep_msg,
592 u8 flow_ctrl)
593 {
594 rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xFE) |
595 (flow_ctrl & 0x1));
596 }
597
cm_rep_get_rnr_retry_count(struct cm_rep_msg * rep_msg)598 static inline u8 cm_rep_get_rnr_retry_count(struct cm_rep_msg *rep_msg)
599 {
600 return (u8) (rep_msg->offset27 >> 5);
601 }
602
cm_rep_set_rnr_retry_count(struct cm_rep_msg * rep_msg,u8 rnr_retry_count)603 static inline void cm_rep_set_rnr_retry_count(struct cm_rep_msg *rep_msg,
604 u8 rnr_retry_count)
605 {
606 rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0x1F) |
607 (rnr_retry_count << 5));
608 }
609
cm_rep_get_srq(struct cm_rep_msg * rep_msg)610 static inline u8 cm_rep_get_srq(struct cm_rep_msg *rep_msg)
611 {
612 return (u8) ((rep_msg->offset27 >> 4) & 0x1);
613 }
614
cm_rep_set_srq(struct cm_rep_msg * rep_msg,u8 srq)615 static inline void cm_rep_set_srq(struct cm_rep_msg *rep_msg, u8 srq)
616 {
617 rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0xEF) |
618 ((srq & 0x1) << 4));
619 }
620
621 struct cm_rtu_msg {
622 struct ib_mad_hdr hdr;
623
624 __be32 local_comm_id;
625 __be32 remote_comm_id;
626
627 u8 private_data[IB_CM_RTU_PRIVATE_DATA_SIZE];
628
629 } __attribute__ ((packed));
630
631 struct cm_dreq_msg {
632 struct ib_mad_hdr hdr;
633
634 __be32 local_comm_id;
635 __be32 remote_comm_id;
636 /* remote QPN/EECN:24, rsvd:8 */
637 __be32 offset8;
638
639 u8 private_data[IB_CM_DREQ_PRIVATE_DATA_SIZE];
640
641 } __attribute__ ((packed));
642
cm_dreq_get_remote_qpn(struct cm_dreq_msg * dreq_msg)643 static inline __be32 cm_dreq_get_remote_qpn(struct cm_dreq_msg *dreq_msg)
644 {
645 return cpu_to_be32(be32_to_cpu(dreq_msg->offset8) >> 8);
646 }
647
cm_dreq_set_remote_qpn(struct cm_dreq_msg * dreq_msg,__be32 qpn)648 static inline void cm_dreq_set_remote_qpn(struct cm_dreq_msg *dreq_msg, __be32 qpn)
649 {
650 dreq_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
651 (be32_to_cpu(dreq_msg->offset8) & 0x000000FF));
652 }
653
654 struct cm_drep_msg {
655 struct ib_mad_hdr hdr;
656
657 __be32 local_comm_id;
658 __be32 remote_comm_id;
659
660 u8 private_data[IB_CM_DREP_PRIVATE_DATA_SIZE];
661
662 } __attribute__ ((packed));
663
664 struct cm_lap_msg {
665 struct ib_mad_hdr hdr;
666
667 __be32 local_comm_id;
668 __be32 remote_comm_id;
669
670 __be32 rsvd8;
671 /* remote QPN/EECN:24, remote CM response timeout:5, rsvd:3 */
672 __be32 offset12;
673 __be32 rsvd16;
674
675 __be16 alt_local_lid;
676 __be16 alt_remote_lid;
677 union ib_gid alt_local_gid;
678 union ib_gid alt_remote_gid;
679 /* flow label:20, rsvd:4, traffic class:8 */
680 __be32 offset56;
681 u8 alt_hop_limit;
682 /* rsvd:2, packet rate:6 */
683 u8 offset61;
684 /* SL:4, subnet local:1, rsvd:3 */
685 u8 offset62;
686 /* local ACK timeout:5, rsvd:3 */
687 u8 offset63;
688
689 u8 private_data[IB_CM_LAP_PRIVATE_DATA_SIZE];
690 } __attribute__ ((packed));
691
cm_lap_get_remote_qpn(struct cm_lap_msg * lap_msg)692 static inline __be32 cm_lap_get_remote_qpn(struct cm_lap_msg *lap_msg)
693 {
694 return cpu_to_be32(be32_to_cpu(lap_msg->offset12) >> 8);
695 }
696
cm_lap_set_remote_qpn(struct cm_lap_msg * lap_msg,__be32 qpn)697 static inline void cm_lap_set_remote_qpn(struct cm_lap_msg *lap_msg, __be32 qpn)
698 {
699 lap_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
700 (be32_to_cpu(lap_msg->offset12) &
701 0x000000FF));
702 }
703
cm_lap_get_remote_resp_timeout(struct cm_lap_msg * lap_msg)704 static inline u8 cm_lap_get_remote_resp_timeout(struct cm_lap_msg *lap_msg)
705 {
706 return (u8) ((be32_to_cpu(lap_msg->offset12) & 0xF8) >> 3);
707 }
708
cm_lap_set_remote_resp_timeout(struct cm_lap_msg * lap_msg,u8 resp_timeout)709 static inline void cm_lap_set_remote_resp_timeout(struct cm_lap_msg *lap_msg,
710 u8 resp_timeout)
711 {
712 lap_msg->offset12 = cpu_to_be32((resp_timeout << 3) |
713 (be32_to_cpu(lap_msg->offset12) &
714 0xFFFFFF07));
715 }
716
cm_lap_get_flow_label(struct cm_lap_msg * lap_msg)717 static inline __be32 cm_lap_get_flow_label(struct cm_lap_msg *lap_msg)
718 {
719 return cpu_to_be32(be32_to_cpu(lap_msg->offset56) >> 12);
720 }
721
cm_lap_set_flow_label(struct cm_lap_msg * lap_msg,__be32 flow_label)722 static inline void cm_lap_set_flow_label(struct cm_lap_msg *lap_msg,
723 __be32 flow_label)
724 {
725 lap_msg->offset56 = cpu_to_be32(
726 (be32_to_cpu(lap_msg->offset56) & 0x00000FFF) |
727 (be32_to_cpu(flow_label) << 12));
728 }
729
cm_lap_get_traffic_class(struct cm_lap_msg * lap_msg)730 static inline u8 cm_lap_get_traffic_class(struct cm_lap_msg *lap_msg)
731 {
732 return (u8) be32_to_cpu(lap_msg->offset56);
733 }
734
cm_lap_set_traffic_class(struct cm_lap_msg * lap_msg,u8 traffic_class)735 static inline void cm_lap_set_traffic_class(struct cm_lap_msg *lap_msg,
736 u8 traffic_class)
737 {
738 lap_msg->offset56 = cpu_to_be32(traffic_class |
739 (be32_to_cpu(lap_msg->offset56) &
740 0xFFFFFF00));
741 }
742
cm_lap_get_packet_rate(struct cm_lap_msg * lap_msg)743 static inline u8 cm_lap_get_packet_rate(struct cm_lap_msg *lap_msg)
744 {
745 return lap_msg->offset61 & 0x3F;
746 }
747
cm_lap_set_packet_rate(struct cm_lap_msg * lap_msg,u8 packet_rate)748 static inline void cm_lap_set_packet_rate(struct cm_lap_msg *lap_msg,
749 u8 packet_rate)
750 {
751 lap_msg->offset61 = (packet_rate & 0x3F) | (lap_msg->offset61 & 0xC0);
752 }
753
cm_lap_get_sl(struct cm_lap_msg * lap_msg)754 static inline u8 cm_lap_get_sl(struct cm_lap_msg *lap_msg)
755 {
756 return lap_msg->offset62 >> 4;
757 }
758
cm_lap_set_sl(struct cm_lap_msg * lap_msg,u8 sl)759 static inline void cm_lap_set_sl(struct cm_lap_msg *lap_msg, u8 sl)
760 {
761 lap_msg->offset62 = (sl << 4) | (lap_msg->offset62 & 0x0F);
762 }
763
cm_lap_get_subnet_local(struct cm_lap_msg * lap_msg)764 static inline u8 cm_lap_get_subnet_local(struct cm_lap_msg *lap_msg)
765 {
766 return (lap_msg->offset62 >> 3) & 0x1;
767 }
768
cm_lap_set_subnet_local(struct cm_lap_msg * lap_msg,u8 subnet_local)769 static inline void cm_lap_set_subnet_local(struct cm_lap_msg *lap_msg,
770 u8 subnet_local)
771 {
772 lap_msg->offset62 = ((subnet_local & 0x1) << 3) |
773 (lap_msg->offset61 & 0xF7);
774 }
cm_lap_get_local_ack_timeout(struct cm_lap_msg * lap_msg)775 static inline u8 cm_lap_get_local_ack_timeout(struct cm_lap_msg *lap_msg)
776 {
777 return lap_msg->offset63 >> 3;
778 }
779
cm_lap_set_local_ack_timeout(struct cm_lap_msg * lap_msg,u8 local_ack_timeout)780 static inline void cm_lap_set_local_ack_timeout(struct cm_lap_msg *lap_msg,
781 u8 local_ack_timeout)
782 {
783 lap_msg->offset63 = (local_ack_timeout << 3) |
784 (lap_msg->offset63 & 0x07);
785 }
786
787 struct cm_apr_msg {
788 struct ib_mad_hdr hdr;
789
790 __be32 local_comm_id;
791 __be32 remote_comm_id;
792
793 u8 info_length;
794 u8 ap_status;
795 __be16 rsvd;
796 u8 info[IB_CM_APR_INFO_LENGTH];
797
798 u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE];
799 } __attribute__ ((packed));
800
801 struct cm_sidr_req_msg {
802 struct ib_mad_hdr hdr;
803
804 __be32 request_id;
805 __be16 pkey;
806 __be16 rsvd;
807 __be64 service_id;
808
809 u32 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE / sizeof(u32)];
810 } __attribute__ ((packed));
811
812 struct cm_sidr_rep_msg {
813 struct ib_mad_hdr hdr;
814
815 __be32 request_id;
816 u8 status;
817 u8 info_length;
818 __be16 rsvd;
819 /* QPN:24, rsvd:8 */
820 __be32 offset8;
821 __be64 service_id;
822 __be32 qkey;
823 u8 info[IB_CM_SIDR_REP_INFO_LENGTH];
824
825 u8 private_data[IB_CM_SIDR_REP_PRIVATE_DATA_SIZE];
826 } __attribute__ ((packed));
827
cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg * sidr_rep_msg)828 static inline __be32 cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg *sidr_rep_msg)
829 {
830 return cpu_to_be32(be32_to_cpu(sidr_rep_msg->offset8) >> 8);
831 }
832
cm_sidr_rep_set_qpn(struct cm_sidr_rep_msg * sidr_rep_msg,__be32 qpn)833 static inline void cm_sidr_rep_set_qpn(struct cm_sidr_rep_msg *sidr_rep_msg,
834 __be32 qpn)
835 {
836 sidr_rep_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
837 (be32_to_cpu(sidr_rep_msg->offset8) &
838 0x000000FF));
839 }
840
841 #endif /* CM_MSGS_H */
842