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