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