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