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