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 u8 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE]; 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 u8 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE]; 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 */ 837