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 #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      __constant_htons(0x0010)
  48 #define CM_MRA_ATTR_ID      __constant_htons(0x0011)
  49 #define CM_REJ_ATTR_ID      __constant_htons(0x0012)
  50 #define CM_REP_ATTR_ID      __constant_htons(0x0013)
  51 #define CM_RTU_ATTR_ID      __constant_htons(0x0014)
  52 #define CM_DREQ_ATTR_ID     __constant_htons(0x0015)
  53 #define CM_DREP_ATTR_ID     __constant_htons(0x0016)
  54 #define CM_SIDR_REQ_ATTR_ID __constant_htons(0x0017)
  55 #define CM_SIDR_REP_ATTR_ID __constant_htons(0x0018)
  56 #define CM_LAP_ATTR_ID      __constant_htons(0x0019)
  57 #define CM_APR_ATTR_ID      __constant_htons(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 */