← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/infiniband/core/cm_msgs.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/infiniband/core/cm_msgs.h
 
1
/*
 
2
 * Copyright (c) 2004, 2011 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, extended transport type: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
        case 3:
 
179
                switch (req_msg->offset51 & 0x7) {
 
180
                case 1: return IB_QPT_XRC_TGT;
 
181
                default: return 0;
 
182
                }
 
183
        default: return 0;
 
184
        }
 
185
}
 
186
 
 
187
static inline void cm_req_set_qp_type(struct cm_req_msg *req_msg,
 
188
                                      enum ib_qp_type qp_type)
 
189
{
 
190
        switch(qp_type) {
 
191
        case IB_QPT_UC:
 
192
                req_msg->offset40 = cpu_to_be32((be32_to_cpu(
 
193
                                                  req_msg->offset40) &
 
194
                                                   0xFFFFFFF9) | 0x2);
 
195
                break;
 
196
        case IB_QPT_XRC_INI:
 
197
                req_msg->offset40 = cpu_to_be32((be32_to_cpu(
 
198
                                                 req_msg->offset40) &
 
199
                                                   0xFFFFFFF9) | 0x6);
 
200
                req_msg->offset51 = (req_msg->offset51 & 0xF8) | 1;
 
201
                break;
 
202
        default:
 
203
                req_msg->offset40 = cpu_to_be32(be32_to_cpu(
 
204
                                                 req_msg->offset40) &
 
205
                                                  0xFFFFFFF9);
 
206
        }
 
207
}
 
208
 
 
209
static inline u8 cm_req_get_flow_ctrl(struct cm_req_msg *req_msg)
 
210
{
 
211
        return be32_to_cpu(req_msg->offset40) & 0x1;
 
212
}
 
213
 
 
214
static inline void cm_req_set_flow_ctrl(struct cm_req_msg *req_msg,
 
215
                                        u8 flow_ctrl)
 
216
{
 
217
        req_msg->offset40 = cpu_to_be32((flow_ctrl & 0x1) |
 
218
                                         (be32_to_cpu(req_msg->offset40) &
 
219
                                          0xFFFFFFFE));
 
220
}
 
221
 
 
222
static inline __be32 cm_req_get_starting_psn(struct cm_req_msg *req_msg)
 
223
{
 
224
        return cpu_to_be32(be32_to_cpu(req_msg->offset44) >> 8);
 
225
}
 
226
 
 
227
static inline void cm_req_set_starting_psn(struct cm_req_msg *req_msg,
 
228
                                           __be32 starting_psn)
 
229
{
 
230
        req_msg->offset44 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) |
 
231
                            (be32_to_cpu(req_msg->offset44) & 0x000000FF));
 
232
}
 
233
 
 
234
static inline u8 cm_req_get_local_resp_timeout(struct cm_req_msg *req_msg)
 
235
{
 
236
        return (u8) ((be32_to_cpu(req_msg->offset44) & 0xF8) >> 3);
 
237
}
 
238
 
 
239
static inline void cm_req_set_local_resp_timeout(struct cm_req_msg *req_msg,
 
240
                                                 u8 resp_timeout)
 
241
{
 
242
        req_msg->offset44 = cpu_to_be32((resp_timeout << 3) |
 
243
                            (be32_to_cpu(req_msg->offset44) & 0xFFFFFF07));
 
244
}
 
245
 
 
246
static inline u8 cm_req_get_retry_count(struct cm_req_msg *req_msg)
 
247
{
 
248
        return (u8) (be32_to_cpu(req_msg->offset44) & 0x7);
 
249
}
 
250
 
 
251
static inline void cm_req_set_retry_count(struct cm_req_msg *req_msg,
 
252
                                          u8 retry_count)
 
253
{
 
254
        req_msg->offset44 = cpu_to_be32((retry_count & 0x7) |
 
255
                            (be32_to_cpu(req_msg->offset44) & 0xFFFFFFF8));
 
256
}
 
257
 
 
258
static inline u8 cm_req_get_path_mtu(struct cm_req_msg *req_msg)
 
259
{
 
260
        return req_msg->offset50 >> 4;
 
261
}
 
262
 
 
263
static inline void cm_req_set_path_mtu(struct cm_req_msg *req_msg, u8 path_mtu)
 
264
{
 
265
        req_msg->offset50 = (u8) ((req_msg->offset50 & 0xF) | (path_mtu << 4));
 
266
}
 
267
 
 
268
static inline u8 cm_req_get_rnr_retry_count(struct cm_req_msg *req_msg)
 
269
{
 
270
        return req_msg->offset50 & 0x7;
 
271
}
 
272
 
 
273
static inline void cm_req_set_rnr_retry_count(struct cm_req_msg *req_msg,
 
274
                                              u8 rnr_retry_count)
 
275
{
 
276
        req_msg->offset50 = (u8) ((req_msg->offset50 & 0xF8) |
 
277
                                  (rnr_retry_count & 0x7));
 
278
}
 
279
 
 
280
static inline u8 cm_req_get_max_cm_retries(struct cm_req_msg *req_msg)
 
281
{
 
282
        return req_msg->offset51 >> 4;
 
283
}
 
284
 
 
285
static inline void cm_req_set_max_cm_retries(struct cm_req_msg *req_msg,
 
286
                                             u8 retries)
 
287
{
 
288
        req_msg->offset51 = (u8) ((req_msg->offset51 & 0xF) | (retries << 4));
 
289
}
 
290
 
 
291
static inline u8 cm_req_get_srq(struct cm_req_msg *req_msg)
 
292
{
 
293
        return (req_msg->offset51 & 0x8) >> 3;
 
294
}
 
295
 
 
296
static inline void cm_req_set_srq(struct cm_req_msg *req_msg, u8 srq)
 
297
{
 
298
        req_msg->offset51 = (u8) ((req_msg->offset51 & 0xF7) |
 
299
                                  ((srq & 0x1) << 3));
 
300
}
 
301
 
 
302
static inline __be32 cm_req_get_primary_flow_label(struct cm_req_msg *req_msg)
 
303
{
 
304
        return cpu_to_be32(be32_to_cpu(req_msg->primary_offset88) >> 12);
 
305
}
 
306
 
 
307
static inline void cm_req_set_primary_flow_label(struct cm_req_msg *req_msg,
 
308
                                                 __be32 flow_label)
 
309
{
 
310
        req_msg->primary_offset88 = cpu_to_be32(
 
311
                                    (be32_to_cpu(req_msg->primary_offset88) &
 
312
                                     0x00000FFF) |
 
313
                                     (be32_to_cpu(flow_label) << 12));
 
314
}
 
315
 
 
316
static inline u8 cm_req_get_primary_packet_rate(struct cm_req_msg *req_msg)
 
317
{
 
318
        return (u8) (be32_to_cpu(req_msg->primary_offset88) & 0x3F);
 
319
}
 
320
 
 
321
static inline void cm_req_set_primary_packet_rate(struct cm_req_msg *req_msg,
 
322
                                                  u8 rate)
 
323
{
 
324
        req_msg->primary_offset88 = cpu_to_be32(
 
325
                                    (be32_to_cpu(req_msg->primary_offset88) &
 
326
                                     0xFFFFFFC0) | (rate & 0x3F));
 
327
}
 
328
 
 
329
static inline u8 cm_req_get_primary_sl(struct cm_req_msg *req_msg)
 
330
{
 
331
        return (u8) (req_msg->primary_offset94 >> 4);
 
332
}
 
333
 
 
334
static inline void cm_req_set_primary_sl(struct cm_req_msg *req_msg, u8 sl)
 
335
{
 
336
        req_msg->primary_offset94 = (u8) ((req_msg->primary_offset94 & 0x0F) |
 
337
                                          (sl << 4));
 
338
}
 
339
 
 
340
static inline u8 cm_req_get_primary_subnet_local(struct cm_req_msg *req_msg)
 
341
{
 
342
        return (u8) ((req_msg->primary_offset94 & 0x08) >> 3);
 
343
}
 
344
 
 
345
static inline void cm_req_set_primary_subnet_local(struct cm_req_msg *req_msg,
 
346
                                                   u8 subnet_local)
 
347
{
 
348
        req_msg->primary_offset94 = (u8) ((req_msg->primary_offset94 & 0xF7) |
 
349
                                          ((subnet_local & 0x1) << 3));
 
350
}
 
351
 
 
352
static inline u8 cm_req_get_primary_local_ack_timeout(struct cm_req_msg *req_msg)
 
353
{
 
354
        return (u8) (req_msg->primary_offset95 >> 3);
 
355
}
 
356
 
 
357
static inline void cm_req_set_primary_local_ack_timeout(struct cm_req_msg *req_msg,
 
358
                                                        u8 local_ack_timeout)
 
359
{
 
360
        req_msg->primary_offset95 = (u8) ((req_msg->primary_offset95 & 0x07) |
 
361
                                          (local_ack_timeout << 3));
 
362
}
 
363
 
 
364
static inline __be32 cm_req_get_alt_flow_label(struct cm_req_msg *req_msg)
 
365
{
 
366
        return cpu_to_be32(be32_to_cpu(req_msg->alt_offset132) >> 12);
 
367
}
 
368
 
 
369
static inline void cm_req_set_alt_flow_label(struct cm_req_msg *req_msg,
 
370
                                             __be32 flow_label)
 
371
{
 
372
        req_msg->alt_offset132 = cpu_to_be32(
 
373
                                 (be32_to_cpu(req_msg->alt_offset132) &
 
374
                                  0x00000FFF) |
 
375
                                  (be32_to_cpu(flow_label) << 12));
 
376
}
 
377
 
 
378
static inline u8 cm_req_get_alt_packet_rate(struct cm_req_msg *req_msg)
 
379
{
 
380
        return (u8) (be32_to_cpu(req_msg->alt_offset132) & 0x3F);
 
381
}
 
382
 
 
383
static inline void cm_req_set_alt_packet_rate(struct cm_req_msg *req_msg,
 
384
                                              u8 rate)
 
385
{
 
386
        req_msg->alt_offset132 = cpu_to_be32(
 
387
                                 (be32_to_cpu(req_msg->alt_offset132) &
 
388
                                  0xFFFFFFC0) | (rate & 0x3F));
 
389
}
 
390
 
 
391
static inline u8 cm_req_get_alt_sl(struct cm_req_msg *req_msg)
 
392
{
 
393
        return (u8) (req_msg->alt_offset138 >> 4);
 
394
}
 
395
 
 
396
static inline void cm_req_set_alt_sl(struct cm_req_msg *req_msg, u8 sl)
 
397
{
 
398
        req_msg->alt_offset138 = (u8) ((req_msg->alt_offset138 & 0x0F) |
 
399
                                       (sl << 4));
 
400
}
 
401
 
 
402
static inline u8 cm_req_get_alt_subnet_local(struct cm_req_msg *req_msg)
 
403
{
 
404
        return (u8) ((req_msg->alt_offset138 & 0x08) >> 3);
 
405
}
 
406
 
 
407
static inline void cm_req_set_alt_subnet_local(struct cm_req_msg *req_msg,
 
408
                                               u8 subnet_local)
 
409
{
 
410
        req_msg->alt_offset138 = (u8) ((req_msg->alt_offset138 & 0xF7) |
 
411
                                       ((subnet_local & 0x1) << 3));
 
412
}
 
413
 
 
414
static inline u8 cm_req_get_alt_local_ack_timeout(struct cm_req_msg *req_msg)
 
415
{
 
416
        return (u8) (req_msg->alt_offset139 >> 3);
 
417
}
 
418
 
 
419
static inline void cm_req_set_alt_local_ack_timeout(struct cm_req_msg *req_msg,
 
420
                                                    u8 local_ack_timeout)
 
421
{
 
422
        req_msg->alt_offset139 = (u8) ((req_msg->alt_offset139 & 0x07) |
 
423
                                       (local_ack_timeout << 3));
 
424
}
 
425
 
 
426
/* Message REJected or MRAed */
 
427
enum cm_msg_response {
 
428
        CM_MSG_RESPONSE_REQ = 0x0,
 
429
        CM_MSG_RESPONSE_REP = 0x1,
 
430
        CM_MSG_RESPONSE_OTHER = 0x2
 
431
};
 
432
 
 
433
 struct cm_mra_msg {
 
434
        struct ib_mad_hdr hdr;
 
435
 
 
436
        __be32 local_comm_id;
 
437
        __be32 remote_comm_id;
 
438
        /* message MRAed:2, rsvd:6 */
 
439
        u8 offset8;
 
440
        /* service timeout:5, rsvd:3 */
 
441
        u8 offset9;
 
442
 
 
443
        u8 private_data[IB_CM_MRA_PRIVATE_DATA_SIZE];
 
444
 
 
445
} __attribute__ ((packed));
 
446
 
 
447
static inline u8 cm_mra_get_msg_mraed(struct cm_mra_msg *mra_msg)
 
448
{
 
449
        return (u8) (mra_msg->offset8 >> 6);
 
450
}
 
451
 
 
452
static inline void cm_mra_set_msg_mraed(struct cm_mra_msg *mra_msg, u8 msg)
 
453
{
 
454
        mra_msg->offset8 = (u8) ((mra_msg->offset8 & 0x3F) | (msg << 6));
 
455
}
 
456
 
 
457
static inline u8 cm_mra_get_service_timeout(struct cm_mra_msg *mra_msg)
 
458
{
 
459
        return (u8) (mra_msg->offset9 >> 3);
 
460
}
 
461
 
 
462
static inline void cm_mra_set_service_timeout(struct cm_mra_msg *mra_msg,
 
463
                                              u8 service_timeout)
 
464
{
 
465
        mra_msg->offset9 = (u8) ((mra_msg->offset9 & 0x07) |
 
466
                                 (service_timeout << 3));
 
467
}
 
468
 
 
469
struct cm_rej_msg {
 
470
        struct ib_mad_hdr hdr;
 
471
 
 
472
        __be32 local_comm_id;
 
473
        __be32 remote_comm_id;
 
474
        /* message REJected:2, rsvd:6 */
 
475
        u8 offset8;
 
476
        /* reject info length:7, rsvd:1. */
 
477
        u8 offset9;
 
478
        __be16 reason;
 
479
        u8 ari[IB_CM_REJ_ARI_LENGTH];
 
480
 
 
481
        u8 private_data[IB_CM_REJ_PRIVATE_DATA_SIZE];
 
482
 
 
483
} __attribute__ ((packed));
 
484
 
 
485
static inline u8 cm_rej_get_msg_rejected(struct cm_rej_msg *rej_msg)
 
486
{
 
487
        return (u8) (rej_msg->offset8 >> 6);
 
488
}
 
489
 
 
490
static inline void cm_rej_set_msg_rejected(struct cm_rej_msg *rej_msg, u8 msg)
 
491
{
 
492
        rej_msg->offset8 = (u8) ((rej_msg->offset8 & 0x3F) | (msg << 6));
 
493
}
 
494
 
 
495
static inline u8 cm_rej_get_reject_info_len(struct cm_rej_msg *rej_msg)
 
496
{
 
497
        return (u8) (rej_msg->offset9 >> 1);
 
498
}
 
499
 
 
500
static inline void cm_rej_set_reject_info_len(struct cm_rej_msg *rej_msg,
 
501
                                              u8 len)
 
502
{
 
503
        rej_msg->offset9 = (u8) ((rej_msg->offset9 & 0x1) | (len << 1));
 
504
}
 
505
 
 
506
struct cm_rep_msg {
 
507
        struct ib_mad_hdr hdr;
 
508
 
 
509
        __be32 local_comm_id;
 
510
        __be32 remote_comm_id;
 
511
        __be32 local_qkey;
 
512
        /* local QPN:24, rsvd:8 */
 
513
        __be32 offset12;
 
514
        /* local EECN:24, rsvd:8 */
 
515
        __be32 offset16;
 
516
        /* starting PSN:24 rsvd:8 */
 
517
        __be32 offset20;
 
518
        u8 resp_resources;
 
519
        u8 initiator_depth;
 
520
        /* target ACK delay:5, failover accepted:2, end-to-end flow control:1 */
 
521
        u8 offset26;
 
522
        /* RNR retry count:3, SRQ:1, rsvd:5 */
 
523
        u8 offset27;
 
524
        __be64 local_ca_guid;
 
525
 
 
526
        u8 private_data[IB_CM_REP_PRIVATE_DATA_SIZE];
 
527
 
 
528
} __attribute__ ((packed));
 
529
 
 
530
static inline __be32 cm_rep_get_local_qpn(struct cm_rep_msg *rep_msg)
 
531
{
 
532
        return cpu_to_be32(be32_to_cpu(rep_msg->offset12) >> 8);
 
533
}
 
534
 
 
535
static inline void cm_rep_set_local_qpn(struct cm_rep_msg *rep_msg, __be32 qpn)
 
536
{
 
537
        rep_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
 
538
                            (be32_to_cpu(rep_msg->offset12) & 0x000000FF));
 
539
}
 
540
 
 
541
static inline __be32 cm_rep_get_local_eecn(struct cm_rep_msg *rep_msg)
 
542
{
 
543
        return cpu_to_be32(be32_to_cpu(rep_msg->offset16) >> 8);
 
544
}
 
545
 
 
546
static inline void cm_rep_set_local_eecn(struct cm_rep_msg *rep_msg, __be32 eecn)
 
547
{
 
548
        rep_msg->offset16 = cpu_to_be32((be32_to_cpu(eecn) << 8) |
 
549
                            (be32_to_cpu(rep_msg->offset16) & 0x000000FF));
 
550
}
 
551
 
 
552
static inline __be32 cm_rep_get_qpn(struct cm_rep_msg *rep_msg, enum ib_qp_type qp_type)
 
553
{
 
554
        return (qp_type == IB_QPT_XRC_INI) ?
 
555
                cm_rep_get_local_eecn(rep_msg) : cm_rep_get_local_qpn(rep_msg);
 
556
}
 
557
 
 
558
static inline __be32 cm_rep_get_starting_psn(struct cm_rep_msg *rep_msg)
 
559
{
 
560
        return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8);
 
561
}
 
562
 
 
563
static inline void cm_rep_set_starting_psn(struct cm_rep_msg *rep_msg,
 
564
                                           __be32 starting_psn)
 
565
{
 
566
        rep_msg->offset20 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) |
 
567
                            (be32_to_cpu(rep_msg->offset20) & 0x000000FF));
 
568
}
 
569
 
 
570
static inline u8 cm_rep_get_target_ack_delay(struct cm_rep_msg *rep_msg)
 
571
{
 
572
        return (u8) (rep_msg->offset26 >> 3);
 
573
}
 
574
 
 
575
static inline void cm_rep_set_target_ack_delay(struct cm_rep_msg *rep_msg,
 
576
                                               u8 target_ack_delay)
 
577
{
 
578
        rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0x07) |
 
579
                                  (target_ack_delay << 3));
 
580
}
 
581
 
 
582
static inline u8 cm_rep_get_failover(struct cm_rep_msg *rep_msg)
 
583
{
 
584
        return (u8) ((rep_msg->offset26 & 0x06) >> 1);
 
585
}
 
586
 
 
587
static inline void cm_rep_set_failover(struct cm_rep_msg *rep_msg, u8 failover)
 
588
{
 
589
        rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xF9) |
 
590
                                  ((failover & 0x3) << 1));
 
591
}
 
592
 
 
593
static inline u8 cm_rep_get_flow_ctrl(struct cm_rep_msg *rep_msg)
 
594
{
 
595
        return (u8) (rep_msg->offset26 & 0x01);
 
596
}
 
597
 
 
598
static inline void cm_rep_set_flow_ctrl(struct cm_rep_msg *rep_msg,
 
599
                                            u8 flow_ctrl)
 
600
{
 
601
        rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xFE) |
 
602
                                  (flow_ctrl & 0x1));
 
603
}
 
604
 
 
605
static inline u8 cm_rep_get_rnr_retry_count(struct cm_rep_msg *rep_msg)
 
606
{
 
607
        return (u8) (rep_msg->offset27 >> 5);
 
608
}
 
609
 
 
610
static inline void cm_rep_set_rnr_retry_count(struct cm_rep_msg *rep_msg,
 
611
                                              u8 rnr_retry_count)
 
612
{
 
613
        rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0x1F) |
 
614
                                  (rnr_retry_count << 5));
 
615
}
 
616
 
 
617
static inline u8 cm_rep_get_srq(struct cm_rep_msg *rep_msg)
 
618
{
 
619
        return (u8) ((rep_msg->offset27 >> 4) & 0x1);
 
620
}
 
621
 
 
622
static inline void cm_rep_set_srq(struct cm_rep_msg *rep_msg, u8 srq)
 
623
{
 
624
        rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0xEF) |
 
625
                                  ((srq & 0x1) << 4));
 
626
}
 
627
 
 
628
struct cm_rtu_msg {
 
629
        struct ib_mad_hdr hdr;
 
630
 
 
631
        __be32 local_comm_id;
 
632
        __be32 remote_comm_id;
 
633
 
 
634
        u8 private_data[IB_CM_RTU_PRIVATE_DATA_SIZE];
 
635
 
 
636
} __attribute__ ((packed));
 
637
 
 
638
struct cm_dreq_msg {
 
639
        struct ib_mad_hdr hdr;
 
640
 
 
641
        __be32 local_comm_id;
 
642
        __be32 remote_comm_id;
 
643
        /* remote QPN/EECN:24, rsvd:8 */
 
644
        __be32 offset8;
 
645
 
 
646
        u8 private_data[IB_CM_DREQ_PRIVATE_DATA_SIZE];
 
647
 
 
648
} __attribute__ ((packed));
 
649
 
 
650
static inline __be32 cm_dreq_get_remote_qpn(struct cm_dreq_msg *dreq_msg)
 
651
{
 
652
        return cpu_to_be32(be32_to_cpu(dreq_msg->offset8) >> 8);
 
653
}
 
654
 
 
655
static inline void cm_dreq_set_remote_qpn(struct cm_dreq_msg *dreq_msg, __be32 qpn)
 
656
{
 
657
        dreq_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
 
658
                            (be32_to_cpu(dreq_msg->offset8) & 0x000000FF));
 
659
}
 
660
 
 
661
struct cm_drep_msg {
 
662
        struct ib_mad_hdr hdr;
 
663
 
 
664
        __be32 local_comm_id;
 
665
        __be32 remote_comm_id;
 
666
 
 
667
        u8 private_data[IB_CM_DREP_PRIVATE_DATA_SIZE];
 
668
 
 
669
} __attribute__ ((packed));
 
670
 
 
671
struct cm_lap_msg {
 
672
        struct ib_mad_hdr hdr;
 
673
 
 
674
        __be32 local_comm_id;
 
675
        __be32 remote_comm_id;
 
676
 
 
677
        __be32 rsvd8;
 
678
        /* remote QPN/EECN:24, remote CM response timeout:5, rsvd:3 */
 
679
        __be32 offset12;
 
680
        __be32 rsvd16;
 
681
 
 
682
        __be16 alt_local_lid;
 
683
        __be16 alt_remote_lid;
 
684
        union ib_gid alt_local_gid;
 
685
        union ib_gid alt_remote_gid;
 
686
        /* flow label:20, rsvd:4, traffic class:8 */
 
687
        __be32 offset56;
 
688
        u8 alt_hop_limit;
 
689
        /* rsvd:2, packet rate:6 */
 
690
        u8 offset61;
 
691
        /* SL:4, subnet local:1, rsvd:3 */
 
692
        u8 offset62;
 
693
        /* local ACK timeout:5, rsvd:3 */
 
694
        u8 offset63;
 
695
 
 
696
        u8 private_data[IB_CM_LAP_PRIVATE_DATA_SIZE];
 
697
} __attribute__  ((packed));
 
698
 
 
699
static inline __be32 cm_lap_get_remote_qpn(struct cm_lap_msg *lap_msg)
 
700
{
 
701
        return cpu_to_be32(be32_to_cpu(lap_msg->offset12) >> 8);
 
702
}
 
703
 
 
704
static inline void cm_lap_set_remote_qpn(struct cm_lap_msg *lap_msg, __be32 qpn)
 
705
{
 
706
        lap_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
 
707
                                         (be32_to_cpu(lap_msg->offset12) &
 
708
                                          0x000000FF));
 
709
}
 
710
 
 
711
static inline u8 cm_lap_get_remote_resp_timeout(struct cm_lap_msg *lap_msg)
 
712
{
 
713
        return (u8) ((be32_to_cpu(lap_msg->offset12) & 0xF8) >> 3);
 
714
}
 
715
 
 
716
static inline void cm_lap_set_remote_resp_timeout(struct cm_lap_msg *lap_msg,
 
717
                                                  u8 resp_timeout)
 
718
{
 
719
        lap_msg->offset12 = cpu_to_be32((resp_timeout << 3) |
 
720
                                         (be32_to_cpu(lap_msg->offset12) &
 
721
                                          0xFFFFFF07));
 
722
}
 
723
 
 
724
static inline __be32 cm_lap_get_flow_label(struct cm_lap_msg *lap_msg)
 
725
{
 
726
        return cpu_to_be32(be32_to_cpu(lap_msg->offset56) >> 12);
 
727
}
 
728
 
 
729
static inline void cm_lap_set_flow_label(struct cm_lap_msg *lap_msg,
 
730
                                         __be32 flow_label)
 
731
{
 
732
        lap_msg->offset56 = cpu_to_be32(
 
733
                                 (be32_to_cpu(lap_msg->offset56) & 0x00000FFF) |
 
734
                                 (be32_to_cpu(flow_label) << 12));
 
735
}
 
736
 
 
737
static inline u8 cm_lap_get_traffic_class(struct cm_lap_msg *lap_msg)
 
738
{
 
739
        return (u8) be32_to_cpu(lap_msg->offset56);
 
740
}
 
741
 
 
742
static inline void cm_lap_set_traffic_class(struct cm_lap_msg *lap_msg,
 
743
                                            u8 traffic_class)
 
744
{
 
745
        lap_msg->offset56 = cpu_to_be32(traffic_class |
 
746
                                         (be32_to_cpu(lap_msg->offset56) &
 
747
                                          0xFFFFFF00));
 
748
}
 
749
 
 
750
static inline u8 cm_lap_get_packet_rate(struct cm_lap_msg *lap_msg)
 
751
{
 
752
        return lap_msg->offset61 & 0x3F;
 
753
}
 
754
 
 
755
static inline void cm_lap_set_packet_rate(struct cm_lap_msg *lap_msg,
 
756
                                          u8 packet_rate)
 
757
{
 
758
        lap_msg->offset61 = (packet_rate & 0x3F) | (lap_msg->offset61 & 0xC0);
 
759
}
 
760
 
 
761
static inline u8 cm_lap_get_sl(struct cm_lap_msg *lap_msg)
 
762
{
 
763
        return lap_msg->offset62 >> 4;
 
764
}
 
765
 
 
766
static inline void cm_lap_set_sl(struct cm_lap_msg *lap_msg, u8 sl)
 
767
{
 
768
        lap_msg->offset62 = (sl << 4) | (lap_msg->offset62 & 0x0F);
 
769
}
 
770
 
 
771
static inline u8 cm_lap_get_subnet_local(struct cm_lap_msg *lap_msg)
 
772
{
 
773
        return (lap_msg->offset62 >> 3) & 0x1;
 
774
}
 
775
 
 
776
static inline void cm_lap_set_subnet_local(struct cm_lap_msg *lap_msg,
 
777
                                           u8 subnet_local)
 
778
{
 
779
        lap_msg->offset62 = ((subnet_local & 0x1) << 3) |
 
780
                             (lap_msg->offset61 & 0xF7);
 
781
}
 
782
static inline u8 cm_lap_get_local_ack_timeout(struct cm_lap_msg *lap_msg)
 
783
{
 
784
        return lap_msg->offset63 >> 3;
 
785
}
 
786
 
 
787
static inline void cm_lap_set_local_ack_timeout(struct cm_lap_msg *lap_msg,
 
788
                                                u8 local_ack_timeout)
 
789
{
 
790
        lap_msg->offset63 = (local_ack_timeout << 3) |
 
791
                            (lap_msg->offset63 & 0x07);
 
792
}
 
793
 
 
794
struct cm_apr_msg {
 
795
        struct ib_mad_hdr hdr;
 
796
 
 
797
        __be32 local_comm_id;
 
798
        __be32 remote_comm_id;
 
799
 
 
800
        u8 info_length;
 
801
        u8 ap_status;
 
802
        u8 info[IB_CM_APR_INFO_LENGTH];
 
803
 
 
804
        u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE];
 
805
} __attribute__ ((packed));
 
806
 
 
807
struct cm_sidr_req_msg {
 
808
        struct ib_mad_hdr hdr;
 
809
 
 
810
        __be32 request_id;
 
811
        __be16 pkey;
 
812
        __be16 rsvd;
 
813
        __be64 service_id;
 
814
 
 
815
        u8 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE];
 
816
} __attribute__ ((packed));
 
817
 
 
818
struct cm_sidr_rep_msg {
 
819
        struct ib_mad_hdr hdr;
 
820
 
 
821
        __be32 request_id;
 
822
        u8 status;
 
823
        u8 info_length;
 
824
        __be16 rsvd;
 
825
        /* QPN:24, rsvd:8 */
 
826
        __be32 offset8;
 
827
        __be64 service_id;
 
828
        __be32 qkey;
 
829
        u8 info[IB_CM_SIDR_REP_INFO_LENGTH];
 
830
 
 
831
        u8 private_data[IB_CM_SIDR_REP_PRIVATE_DATA_SIZE];
 
832
} __attribute__ ((packed));
 
833
 
 
834
static inline __be32 cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg *sidr_rep_msg)
 
835
{
 
836
        return cpu_to_be32(be32_to_cpu(sidr_rep_msg->offset8) >> 8);
 
837
}
 
838
 
 
839
static inline void cm_sidr_rep_set_qpn(struct cm_sidr_rep_msg *sidr_rep_msg,
 
840
                                       __be32 qpn)
 
841
{
 
842
        sidr_rep_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
 
843
                                        (be32_to_cpu(sidr_rep_msg->offset8) &
 
844
                                         0x000000FF));
 
845
}
 
846
 
 
847
#endif /* CM_MSGS_H */