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 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_starting_psn(struct cm_rep_msg *rep_msg) 530 { 531 return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8); 532 } 533 534 static inline void cm_rep_set_starting_psn(struct cm_rep_msg *rep_msg, 535 __be32 starting_psn) 536 { 537 rep_msg->offset20 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) | 538 (be32_to_cpu(rep_msg->offset20) & 0x000000FF)); 539 } 540 541 static inline u8 cm_rep_get_target_ack_delay(struct cm_rep_msg *rep_msg) 542 { 543 return (u8) (rep_msg->offset26 >> 3); 544 } 545 546 static inline void cm_rep_set_target_ack_delay(struct cm_rep_msg *rep_msg, 547 u8 target_ack_delay) 548 { 549 rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0x07) | 550 (target_ack_delay << 3)); 551 } 552 553 static inline u8 cm_rep_get_failover(struct cm_rep_msg *rep_msg) 554 { 555 return (u8) ((rep_msg->offset26 & 0x06) >> 1); 556 } 557 558 static inline void cm_rep_set_failover(struct cm_rep_msg *rep_msg, u8 failover) 559 { 560 rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xF9) | 561 ((failover & 0x3) << 1)); 562 } 563 564 static inline u8 cm_rep_get_flow_ctrl(struct cm_rep_msg *rep_msg) 565 { 566 return (u8) (rep_msg->offset26 & 0x01); 567 } 568 569 static inline void cm_rep_set_flow_ctrl(struct cm_rep_msg *rep_msg, 570 u8 flow_ctrl) 571 { 572 rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xFE) | 573 (flow_ctrl & 0x1)); 574 } 575 576 static inline u8 cm_rep_get_rnr_retry_count(struct cm_rep_msg *rep_msg) 577 { 578 return (u8) (rep_msg->offset27 >> 5); 579 } 580 581 static inline void cm_rep_set_rnr_retry_count(struct cm_rep_msg *rep_msg, 582 u8 rnr_retry_count) 583 { 584 rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0x1F) | 585 (rnr_retry_count << 5)); 586 } 587 588 static inline u8 cm_rep_get_srq(struct cm_rep_msg *rep_msg) 589 { 590 return (u8) ((rep_msg->offset27 >> 4) & 0x1); 591 } 592 593 static inline void cm_rep_set_srq(struct cm_rep_msg *rep_msg, u8 srq) 594 { 595 rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0xEF) | 596 ((srq & 0x1) << 4)); 597 } 598 599 struct cm_rtu_msg { 600 struct ib_mad_hdr hdr; 601 602 __be32 local_comm_id; 603 __be32 remote_comm_id; 604 605 u8 private_data[IB_CM_RTU_PRIVATE_DATA_SIZE]; 606 607 } __attribute__ ((packed)); 608 609 struct cm_dreq_msg { 610 struct ib_mad_hdr hdr; 611 612 __be32 local_comm_id; 613 __be32 remote_comm_id; 614 /* remote QPN/EECN:24, rsvd:8 */ 615 __be32 offset8; 616 617 u8 private_data[IB_CM_DREQ_PRIVATE_DATA_SIZE]; 618 619 } __attribute__ ((packed)); 620 621 static inline __be32 cm_dreq_get_remote_qpn(struct cm_dreq_msg *dreq_msg) 622 { 623 return cpu_to_be32(be32_to_cpu(dreq_msg->offset8) >> 8); 624 } 625 626 static inline void cm_dreq_set_remote_qpn(struct cm_dreq_msg *dreq_msg, __be32 qpn) 627 { 628 dreq_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) | 629 (be32_to_cpu(dreq_msg->offset8) & 0x000000FF)); 630 } 631 632 struct cm_drep_msg { 633 struct ib_mad_hdr hdr; 634 635 __be32 local_comm_id; 636 __be32 remote_comm_id; 637 638 u8 private_data[IB_CM_DREP_PRIVATE_DATA_SIZE]; 639 640 } __attribute__ ((packed)); 641 642 struct cm_lap_msg { 643 struct ib_mad_hdr hdr; 644 645 __be32 local_comm_id; 646 __be32 remote_comm_id; 647 648 __be32 rsvd8; 649 /* remote QPN/EECN:24, remote CM response timeout:5, rsvd:3 */ 650 __be32 offset12; 651 __be32 rsvd16; 652 653 __be16 alt_local_lid; 654 __be16 alt_remote_lid; 655 union ib_gid alt_local_gid; 656 union ib_gid alt_remote_gid; 657 /* flow label:20, rsvd:4, traffic class:8 */ 658 __be32 offset56; 659 u8 alt_hop_limit; 660 /* rsvd:2, packet rate:6 */ 661 u8 offset61; 662 /* SL:4, subnet local:1, rsvd:3 */ 663 u8 offset62; 664 /* local ACK timeout:5, rsvd:3 */ 665 u8 offset63; 666 667 u8 private_data[IB_CM_LAP_PRIVATE_DATA_SIZE]; 668 } __attribute__ ((packed)); 669 670 static inline __be32 cm_lap_get_remote_qpn(struct cm_lap_msg *lap_msg) 671 { 672 return cpu_to_be32(be32_to_cpu(lap_msg->offset12) >> 8); 673 } 674 675 static inline void cm_lap_set_remote_qpn(struct cm_lap_msg *lap_msg, __be32 qpn) 676 { 677 lap_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) | 678 (be32_to_cpu(lap_msg->offset12) & 679 0x000000FF)); 680 } 681 682 static inline u8 cm_lap_get_remote_resp_timeout(struct cm_lap_msg *lap_msg) 683 { 684 return (u8) ((be32_to_cpu(lap_msg->offset12) & 0xF8) >> 3); 685 } 686 687 static inline void cm_lap_set_remote_resp_timeout(struct cm_lap_msg *lap_msg, 688 u8 resp_timeout) 689 { 690 lap_msg->offset12 = cpu_to_be32((resp_timeout << 3) | 691 (be32_to_cpu(lap_msg->offset12) & 692 0xFFFFFF07)); 693 } 694 695 static inline __be32 cm_lap_get_flow_label(struct cm_lap_msg *lap_msg) 696 { 697 return cpu_to_be32(be32_to_cpu(lap_msg->offset56) >> 12); 698 } 699 700 static inline void cm_lap_set_flow_label(struct cm_lap_msg *lap_msg, 701 __be32 flow_label) 702 { 703 lap_msg->offset56 = cpu_to_be32( 704 (be32_to_cpu(lap_msg->offset56) & 0x00000FFF) | 705 (be32_to_cpu(flow_label) << 12)); 706 } 707 708 static inline u8 cm_lap_get_traffic_class(struct cm_lap_msg *lap_msg) 709 { 710 return (u8) be32_to_cpu(lap_msg->offset56); 711 } 712 713 static inline void cm_lap_set_traffic_class(struct cm_lap_msg *lap_msg, 714 u8 traffic_class) 715 { 716 lap_msg->offset56 = cpu_to_be32(traffic_class | 717 (be32_to_cpu(lap_msg->offset56) & 718 0xFFFFFF00)); 719 } 720 721 static inline u8 cm_lap_get_packet_rate(struct cm_lap_msg *lap_msg) 722 { 723 return lap_msg->offset61 & 0x3F; 724 } 725 726 static inline void cm_lap_set_packet_rate(struct cm_lap_msg *lap_msg, 727 u8 packet_rate) 728 { 729 lap_msg->offset61 = (packet_rate & 0x3F) | (lap_msg->offset61 & 0xC0); 730 } 731 732 static inline u8 cm_lap_get_sl(struct cm_lap_msg *lap_msg) 733 { 734 return lap_msg->offset62 >> 4; 735 } 736 737 static inline void cm_lap_set_sl(struct cm_lap_msg *lap_msg, u8 sl) 738 { 739 lap_msg->offset62 = (sl << 4) | (lap_msg->offset62 & 0x0F); 740 } 741 742 static inline u8 cm_lap_get_subnet_local(struct cm_lap_msg *lap_msg) 743 { 744 return (lap_msg->offset62 >> 3) & 0x1; 745 } 746 747 static inline void cm_lap_set_subnet_local(struct cm_lap_msg *lap_msg, 748 u8 subnet_local) 749 { 750 lap_msg->offset62 = ((subnet_local & 0x1) << 3) | 751 (lap_msg->offset61 & 0xF7); 752 } 753 static inline u8 cm_lap_get_local_ack_timeout(struct cm_lap_msg *lap_msg) 754 { 755 return lap_msg->offset63 >> 3; 756 } 757 758 static inline void cm_lap_set_local_ack_timeout(struct cm_lap_msg *lap_msg, 759 u8 local_ack_timeout) 760 { 761 lap_msg->offset63 = (local_ack_timeout << 3) | 762 (lap_msg->offset63 & 0x07); 763 } 764 765 struct cm_apr_msg { 766 struct ib_mad_hdr hdr; 767 768 __be32 local_comm_id; 769 __be32 remote_comm_id; 770 771 u8 info_length; 772 u8 ap_status; 773 u8 info[IB_CM_APR_INFO_LENGTH]; 774 775 u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE]; 776 } __attribute__ ((packed)); 777 778 struct cm_sidr_req_msg { 779 struct ib_mad_hdr hdr; 780 781 __be32 request_id; 782 __be16 pkey; 783 __be16 rsvd; 784 __be64 service_id; 785 786 u8 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE]; 787 } __attribute__ ((packed)); 788 789 struct cm_sidr_rep_msg { 790 struct ib_mad_hdr hdr; 791 792 __be32 request_id; 793 u8 status; 794 u8 info_length; 795 __be16 rsvd; 796 /* QPN:24, rsvd:8 */ 797 __be32 offset8; 798 __be64 service_id; 799 __be32 qkey; 800 u8 info[IB_CM_SIDR_REP_INFO_LENGTH]; 801 802 u8 private_data[IB_CM_SIDR_REP_PRIVATE_DATA_SIZE]; 803 } __attribute__ ((packed)); 804 805 static inline __be32 cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg *sidr_rep_msg) 806 { 807 return cpu_to_be32(be32_to_cpu(sidr_rep_msg->offset8) >> 8); 808 } 809 810 static inline void cm_sidr_rep_set_qpn(struct cm_sidr_rep_msg *sidr_rep_msg, 811 __be32 qpn) 812 { 813 sidr_rep_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) | 814 (be32_to_cpu(sidr_rep_msg->offset8) & 815 0x000000FF)); 816 } 817 818 #endif /* CM_MSGS_H */ 819