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 59enum 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 66struct 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 122static 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 127static 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 134static 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 139static 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 146static 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 151static 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 159static 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 164static 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 172static 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 187static 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 209static 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 214static 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 222static 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 227static 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 234static 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 239static 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 246static 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 251static 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 258static inline u8 cm_req_get_path_mtu(struct cm_req_msg *req_msg) 259{ 260 return req_msg->offset50 >> 4; 261} 262 263static 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 268static inline u8 cm_req_get_rnr_retry_count(struct cm_req_msg *req_msg) 269{ 270 return req_msg->offset50 & 0x7; 271} 272 273static 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 280static inline u8 cm_req_get_max_cm_retries(struct cm_req_msg *req_msg) 281{ 282 return req_msg->offset51 >> 4; 283} 284 285static 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 291static inline u8 cm_req_get_srq(struct cm_req_msg *req_msg) 292{ 293 return (req_msg->offset51 & 0x8) >> 3; 294} 295 296static 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 302static 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 307static 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 316static 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 321static 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 329static inline u8 cm_req_get_primary_sl(struct cm_req_msg *req_msg) 330{ 331 return (u8) (req_msg->primary_offset94 >> 4); 332} 333 334static 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 340static 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 345static 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 352static 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 357static 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 364static 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 369static 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 378static 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 383static 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 391static inline u8 cm_req_get_alt_sl(struct cm_req_msg *req_msg) 392{ 393 return (u8) (req_msg->alt_offset138 >> 4); 394} 395 396static 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 402static 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 407static 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 414static 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 419static 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 */ 427enum 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 447static inline u8 cm_mra_get_msg_mraed(struct cm_mra_msg *mra_msg) 448{ 449 return (u8) (mra_msg->offset8 >> 6); 450} 451 452static 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 457static inline u8 cm_mra_get_service_timeout(struct cm_mra_msg *mra_msg) 458{ 459 return (u8) (mra_msg->offset9 >> 3); 460} 461 462static 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 469struct 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 485static inline u8 cm_rej_get_msg_rejected(struct cm_rej_msg *rej_msg) 486{ 487 return (u8) (rej_msg->offset8 >> 6); 488} 489 490static 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 495static inline u8 cm_rej_get_reject_info_len(struct cm_rej_msg *rej_msg) 496{ 497 return (u8) (rej_msg->offset9 >> 1); 498} 499 500static 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 506struct 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 530static 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 535static 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 541static 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 546static 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 552static 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 558static 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 563static 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 570static inline u8 cm_rep_get_target_ack_delay(struct cm_rep_msg *rep_msg) 571{ 572 return (u8) (rep_msg->offset26 >> 3); 573} 574 575static 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 582static inline u8 cm_rep_get_failover(struct cm_rep_msg *rep_msg) 583{ 584 return (u8) ((rep_msg->offset26 & 0x06) >> 1); 585} 586 587static 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 593static inline u8 cm_rep_get_flow_ctrl(struct cm_rep_msg *rep_msg) 594{ 595 return (u8) (rep_msg->offset26 & 0x01); 596} 597 598static 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 605static inline u8 cm_rep_get_rnr_retry_count(struct cm_rep_msg *rep_msg) 606{ 607 return (u8) (rep_msg->offset27 >> 5); 608} 609 610static 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 617static inline u8 cm_rep_get_srq(struct cm_rep_msg *rep_msg) 618{ 619 return (u8) ((rep_msg->offset27 >> 4) & 0x1); 620} 621 622static 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 628struct 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 638struct 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 650static 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 655static 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 661struct 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 671struct 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 699static 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 704static 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 711static 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 716static 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 724static 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 729static 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 737static 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 742static 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 750static inline u8 cm_lap_get_packet_rate(struct cm_lap_msg *lap_msg) 751{ 752 return lap_msg->offset61 & 0x3F; 753} 754 755static 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 761static inline u8 cm_lap_get_sl(struct cm_lap_msg *lap_msg) 762{ 763 return lap_msg->offset62 >> 4; 764} 765 766static 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 771static inline u8 cm_lap_get_subnet_local(struct cm_lap_msg *lap_msg) 772{ 773 return (lap_msg->offset62 >> 3) & 0x1; 774} 775 776static 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} 782static inline u8 cm_lap_get_local_ack_timeout(struct cm_lap_msg *lap_msg) 783{ 784 return lap_msg->offset63 >> 3; 785} 786 787static 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 794struct 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 __be16 rsvd; 803 u8 info[IB_CM_APR_INFO_LENGTH]; 804 805 u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE]; 806} __attribute__ ((packed)); 807 808struct cm_sidr_req_msg { 809 struct ib_mad_hdr hdr; 810 811 __be32 request_id; 812 __be16 pkey; 813 __be16 rsvd; 814 __be64 service_id; 815 816 u8 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE]; 817} __attribute__ ((packed)); 818 819struct cm_sidr_rep_msg { 820 struct ib_mad_hdr hdr; 821 822 __be32 request_id; 823 u8 status; 824 u8 info_length; 825 __be16 rsvd; 826 /* QPN:24, rsvd:8 */ 827 __be32 offset8; 828 __be64 service_id; 829 __be32 qkey; 830 u8 info[IB_CM_SIDR_REP_INFO_LENGTH]; 831 832 u8 private_data[IB_CM_SIDR_REP_PRIVATE_DATA_SIZE]; 833} __attribute__ ((packed)); 834 835static inline __be32 cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg *sidr_rep_msg) 836{ 837 return cpu_to_be32(be32_to_cpu(sidr_rep_msg->offset8) >> 8); 838} 839 840static inline void cm_sidr_rep_set_qpn(struct cm_sidr_rep_msg *sidr_rep_msg, 841 __be32 qpn) 842{ 843 sidr_rep_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) | 844 (be32_to_cpu(sidr_rep_msg->offset8) & 845 0x000000FF)); 846} 847 848#endif /* CM_MSGS_H */ 849