drivers/infiniband/core/cm_msgs.h

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