15a309a77b2b675f65028b3fd3c485f6375204bb
[linux-2.6.git] / drivers / infiniband / core / cm_msgs.h
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 <ib_mad.h>
38
39 /*
40  * Parameters to routines below should be in network-byte order, and values
41  * are returned in network-byte order.
42  */
43
44 #define IB_CM_CLASS_VERSION     2 /* IB specification 1.2 */
45
46 enum cm_msg_attr_id {
47         CM_REQ_ATTR_ID      = __constant_htons(0x0010),
48         CM_MRA_ATTR_ID      = __constant_htons(0x0011),
49         CM_REJ_ATTR_ID      = __constant_htons(0x0012),
50         CM_REP_ATTR_ID      = __constant_htons(0x0013),
51         CM_RTU_ATTR_ID      = __constant_htons(0x0014),
52         CM_DREQ_ATTR_ID     = __constant_htons(0x0015),
53         CM_DREP_ATTR_ID     = __constant_htons(0x0016),
54         CM_SIDR_REQ_ATTR_ID = __constant_htons(0x0017),
55         CM_SIDR_REP_ATTR_ID = __constant_htons(0x0018),
56         CM_LAP_ATTR_ID      = __constant_htons(0x0019),
57         CM_APR_ATTR_ID      = __constant_htons(0x001A)
58 };
59
60 enum cm_msg_sequence {
61         CM_MSG_SEQUENCE_REQ,
62         CM_MSG_SEQUENCE_LAP,
63         CM_MSG_SEQUENCE_DREQ,
64         CM_MSG_SEQUENCE_SIDR
65 };
66
67 struct cm_req_msg {
68         struct ib_mad_hdr hdr;
69
70         u32 local_comm_id;
71         u32 rsvd4;
72         u64 service_id;
73         u64 local_ca_guid;
74         u32 rsvd24;
75         u32 local_qkey;
76         /* local QPN:24, responder resources:8 */
77         u32 offset32;
78         /* local EECN:24, initiator depth:8 */
79         u32 offset36;
80         /*
81          * remote EECN:24, remote CM response timeout:5,
82          * transport service type:2, end-to-end flow control:1
83          */
84         u32 offset40;
85         /* starting PSN:24, local CM response timeout:5, retry count:3 */
86         u32 offset44;
87         u16 pkey;
88         /* path MTU:4, RDC exists:1, RNR retry count:3. */
89         u8 offset50;
90         /* max CM Retries:4, SRQ:1, rsvd:3 */
91         u8 offset51;
92
93         u16 primary_local_lid;
94         u16 primary_remote_lid;
95         union ib_gid primary_local_gid;
96         union ib_gid primary_remote_gid;
97         /* flow label:20, rsvd:6, packet rate:6 */
98         u32 primary_offset88;
99         u8 primary_traffic_class;
100         u8 primary_hop_limit;
101         /* SL:4, subnet local:1, rsvd:3 */
102         u8 primary_offset94;
103         /* local ACK timeout:5, rsvd:3 */
104         u8 primary_offset95;
105
106         u16 alt_local_lid;
107         u16 alt_remote_lid;
108         union ib_gid alt_local_gid;
109         union ib_gid alt_remote_gid;
110         /* flow label:20, rsvd:6, packet rate:6 */
111         u32 alt_offset132;
112         u8 alt_traffic_class;
113         u8 alt_hop_limit;
114         /* SL:4, subnet local:1, rsvd:3 */
115         u8 alt_offset138;
116         /* local ACK timeout:5, rsvd:3 */
117         u8 alt_offset139;
118
119         u8 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE];
120
121 } __attribute__ ((packed));
122
123 static inline u32 cm_req_get_local_qpn(struct cm_req_msg *req_msg)
124 {
125         return cpu_to_be32(be32_to_cpu(req_msg->offset32) >> 8);
126 }
127
128 static inline void cm_req_set_local_qpn(struct cm_req_msg *req_msg, u32 qpn)
129 {
130         req_msg->offset32 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
131                                          (be32_to_cpu(req_msg->offset32) &
132                                           0x000000FF));
133 }
134
135 static inline u8 cm_req_get_resp_res(struct cm_req_msg *req_msg)
136 {
137         return (u8) be32_to_cpu(req_msg->offset32);
138 }
139
140 static inline void cm_req_set_resp_res(struct cm_req_msg *req_msg, u8 resp_res)
141 {
142         req_msg->offset32 = cpu_to_be32(resp_res |
143                                         (be32_to_cpu(req_msg->offset32) &
144                                          0xFFFFFF00));
145 }
146
147 static inline u8 cm_req_get_init_depth(struct cm_req_msg *req_msg)
148 {
149         return (u8) be32_to_cpu(req_msg->offset36);
150 }
151
152 static inline void cm_req_set_init_depth(struct cm_req_msg *req_msg,
153                                          u8 init_depth)
154 {
155         req_msg->offset36 = cpu_to_be32(init_depth |
156                                         (be32_to_cpu(req_msg->offset36) &
157                                          0xFFFFFF00));
158 }
159
160 static inline u8 cm_req_get_remote_resp_timeout(struct cm_req_msg *req_msg)
161 {
162         return (u8) ((be32_to_cpu(req_msg->offset40) & 0xF8) >> 3);
163 }
164
165 static inline void cm_req_set_remote_resp_timeout(struct cm_req_msg *req_msg,
166                                                   u8 resp_timeout)
167 {
168         req_msg->offset40 = cpu_to_be32((resp_timeout << 3) |
169                                          (be32_to_cpu(req_msg->offset40) &
170                                           0xFFFFFF07));
171 }
172
173 static inline enum ib_qp_type cm_req_get_qp_type(struct cm_req_msg *req_msg)
174 {
175         u8 transport_type = (u8) (be32_to_cpu(req_msg->offset40) & 0x06) >> 1;
176         switch(transport_type) {
177         case 0: return IB_QPT_RC;
178         case 1: return IB_QPT_UC;
179         default: return 0;
180         }
181 }
182
183 static inline void cm_req_set_qp_type(struct cm_req_msg *req_msg,
184                                       enum ib_qp_type qp_type)
185 {
186         switch(qp_type) {
187         case IB_QPT_UC:
188                 req_msg->offset40 = cpu_to_be32((be32_to_cpu(
189                                                   req_msg->offset40) &
190                                                    0xFFFFFFF9) | 0x2);
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 u32 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                                            u32 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 u32 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                                                  u32 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 u32 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                                              u32 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         u32 local_comm_id;
426         u32 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         u32 local_comm_id;
462         u32 remote_comm_id;
463         /* message REJected:2, rsvd:6 */
464         u8 offset8;
465         /* reject info length:7, rsvd:1. */
466         u8 offset9;
467         u16 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         u32 local_comm_id;
499         u32 remote_comm_id;
500         u32 local_qkey;
501         /* local QPN:24, rsvd:8 */
502         u32 offset12;
503         /* local EECN:24, rsvd:8 */
504         u32 offset16;
505         /* starting PSN:24 rsvd:8 */
506         u32 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         u64 local_ca_guid;
514
515         u8 private_data[IB_CM_REP_PRIVATE_DATA_SIZE];
516
517 } __attribute__ ((packed));
518
519 static inline u32 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, u32 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 u32 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                                            u32 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         u32 local_comm_id;
604         u32 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         u32 local_comm_id;
614         u32 remote_comm_id;
615         /* remote QPN/EECN:24, rsvd:8 */
616         u32 offset8;
617
618         u8 private_data[IB_CM_DREQ_PRIVATE_DATA_SIZE];
619
620 } __attribute__ ((packed));
621
622 static inline u32 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, u32 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         u32 local_comm_id;
637         u32 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         u32 local_comm_id;
647         u32 remote_comm_id;
648
649         u32 rsvd8;
650         /* remote QPN/EECN:24, remote CM response timeout:5, rsvd:3 */
651         u32 offset12;
652         u32 rsvd16;
653
654         u16 alt_local_lid;
655         u16 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         u32 offset56;
660         u8 alt_hop_limit;
661         /* rsvd:2, packet rate:6 */
662         uint8_t offset61;
663         /* SL:4, subnet local:1, rsvd:3 */
664         uint8_t offset62;
665         /* local ACK timeout:5, rsvd:3 */
666         uint8_t offset63;
667
668         u8 private_data[IB_CM_LAP_PRIVATE_DATA_SIZE];
669 } __attribute__  ((packed));
670
671 static inline u32 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, u32 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 u32 cm_lap_get_flow_label(struct cm_lap_msg *lap_msg)
697 {
698         return 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                                          u32 flow_label)
703 {
704         lap_msg->offset56 = cpu_to_be32((flow_label << 12) |
705                                          (be32_to_cpu(lap_msg->offset56) &
706                                           0x00000FFF));
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         u32 local_comm_id;
770         u32 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         u32 request_id;
783         u16 pkey;
784         u16 rsvd;
785         u64 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         u32 request_id;
794         u8 status;
795         u8 info_length;
796         u16 rsvd;
797         /* QPN:24, rsvd:8 */
798         u32 offset8;
799         u64 service_id;
800         u32 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 u32 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                                        u32 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 */