1 /* 2 * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved. 3 * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved. 4 * 5 * This software is available to you under a choice of one of two 6 * licenses. You may choose to be licensed under the terms of the GNU 7 * General Public License (GPL) Version 2, available from the file 8 * COPYING in the main directory of this source tree, or the 9 * OpenIB.org BSD license below: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * - Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * - Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34 #ifndef RXE_HDR_H 35 #define RXE_HDR_H 36 37 /* extracted information about a packet carried in an sk_buff struct fits in 38 * the skbuff cb array. Must be at most 48 bytes. stored in control block of 39 * sk_buff for received packets. 40 */ 41 struct rxe_pkt_info { 42 struct rxe_dev *rxe; /* device that owns packet */ 43 struct rxe_qp *qp; /* qp that owns packet */ 44 struct rxe_send_wqe *wqe; /* send wqe */ 45 u8 *hdr; /* points to bth */ 46 u32 mask; /* useful info about pkt */ 47 u32 psn; /* bth psn of packet */ 48 u16 pkey_index; /* partition of pkt */ 49 u16 paylen; /* length of bth - icrc */ 50 u8 port_num; /* port pkt received on */ 51 u8 opcode; /* bth opcode of packet */ 52 u8 offset; /* bth offset from pkt->hdr */ 53 }; 54 55 /* Macros should be used only for received skb */ 56 static inline struct rxe_pkt_info *SKB_TO_PKT(struct sk_buff *skb) 57 { 58 BUILD_BUG_ON(sizeof(struct rxe_pkt_info) > sizeof(skb->cb)); 59 return (void *)skb->cb; 60 } 61 62 static inline struct sk_buff *PKT_TO_SKB(struct rxe_pkt_info *pkt) 63 { 64 return container_of((void *)pkt, struct sk_buff, cb); 65 } 66 67 /* 68 * IBA header types and methods 69 * 70 * Some of these are for reference and completeness only since 71 * rxe does not currently support RD transport 72 * most of this could be moved into IB core. ib_pack.h has 73 * part of this but is incomplete 74 * 75 * Header specific routines to insert/extract values to/from headers 76 * the routines that are named __hhh_(set_)fff() take a pointer to a 77 * hhh header and get(set) the fff field. The routines named 78 * hhh_(set_)fff take a packet info struct and find the 79 * header and field based on the opcode in the packet. 80 * Conversion to/from network byte order from cpu order is also done. 81 */ 82 83 #define RXE_ICRC_SIZE (4) 84 #define RXE_MAX_HDR_LENGTH (80) 85 86 /****************************************************************************** 87 * Base Transport Header 88 ******************************************************************************/ 89 struct rxe_bth { 90 u8 opcode; 91 u8 flags; 92 __be16 pkey; 93 __be32 qpn; 94 __be32 apsn; 95 }; 96 97 #define BTH_TVER (0) 98 #define BTH_DEF_PKEY (0xffff) 99 100 #define BTH_SE_MASK (0x80) 101 #define BTH_MIG_MASK (0x40) 102 #define BTH_PAD_MASK (0x30) 103 #define BTH_TVER_MASK (0x0f) 104 #define BTH_FECN_MASK (0x80000000) 105 #define BTH_BECN_MASK (0x40000000) 106 #define BTH_RESV6A_MASK (0x3f000000) 107 #define BTH_QPN_MASK (0x00ffffff) 108 #define BTH_ACK_MASK (0x80000000) 109 #define BTH_RESV7_MASK (0x7f000000) 110 #define BTH_PSN_MASK (0x00ffffff) 111 112 static inline u8 __bth_opcode(void *arg) 113 { 114 struct rxe_bth *bth = arg; 115 116 return bth->opcode; 117 } 118 119 static inline void __bth_set_opcode(void *arg, u8 opcode) 120 { 121 struct rxe_bth *bth = arg; 122 123 bth->opcode = opcode; 124 } 125 126 static inline u8 __bth_se(void *arg) 127 { 128 struct rxe_bth *bth = arg; 129 130 return 0 != (BTH_SE_MASK & bth->flags); 131 } 132 133 static inline void __bth_set_se(void *arg, int se) 134 { 135 struct rxe_bth *bth = arg; 136 137 if (se) 138 bth->flags |= BTH_SE_MASK; 139 else 140 bth->flags &= ~BTH_SE_MASK; 141 } 142 143 static inline u8 __bth_mig(void *arg) 144 { 145 struct rxe_bth *bth = arg; 146 147 return 0 != (BTH_MIG_MASK & bth->flags); 148 } 149 150 static inline void __bth_set_mig(void *arg, u8 mig) 151 { 152 struct rxe_bth *bth = arg; 153 154 if (mig) 155 bth->flags |= BTH_MIG_MASK; 156 else 157 bth->flags &= ~BTH_MIG_MASK; 158 } 159 160 static inline u8 __bth_pad(void *arg) 161 { 162 struct rxe_bth *bth = arg; 163 164 return (BTH_PAD_MASK & bth->flags) >> 4; 165 } 166 167 static inline void __bth_set_pad(void *arg, u8 pad) 168 { 169 struct rxe_bth *bth = arg; 170 171 bth->flags = (BTH_PAD_MASK & (pad << 4)) | 172 (~BTH_PAD_MASK & bth->flags); 173 } 174 175 static inline u8 __bth_tver(void *arg) 176 { 177 struct rxe_bth *bth = arg; 178 179 return BTH_TVER_MASK & bth->flags; 180 } 181 182 static inline void __bth_set_tver(void *arg, u8 tver) 183 { 184 struct rxe_bth *bth = arg; 185 186 bth->flags = (BTH_TVER_MASK & tver) | 187 (~BTH_TVER_MASK & bth->flags); 188 } 189 190 static inline u16 __bth_pkey(void *arg) 191 { 192 struct rxe_bth *bth = arg; 193 194 return be16_to_cpu(bth->pkey); 195 } 196 197 static inline void __bth_set_pkey(void *arg, u16 pkey) 198 { 199 struct rxe_bth *bth = arg; 200 201 bth->pkey = cpu_to_be16(pkey); 202 } 203 204 static inline u32 __bth_qpn(void *arg) 205 { 206 struct rxe_bth *bth = arg; 207 208 return BTH_QPN_MASK & be32_to_cpu(bth->qpn); 209 } 210 211 static inline void __bth_set_qpn(void *arg, u32 qpn) 212 { 213 struct rxe_bth *bth = arg; 214 u32 resvqpn = be32_to_cpu(bth->qpn); 215 216 bth->qpn = cpu_to_be32((BTH_QPN_MASK & qpn) | 217 (~BTH_QPN_MASK & resvqpn)); 218 } 219 220 static inline int __bth_fecn(void *arg) 221 { 222 struct rxe_bth *bth = arg; 223 224 return 0 != (cpu_to_be32(BTH_FECN_MASK) & bth->qpn); 225 } 226 227 static inline void __bth_set_fecn(void *arg, int fecn) 228 { 229 struct rxe_bth *bth = arg; 230 231 if (fecn) 232 bth->qpn |= cpu_to_be32(BTH_FECN_MASK); 233 else 234 bth->qpn &= ~cpu_to_be32(BTH_FECN_MASK); 235 } 236 237 static inline int __bth_becn(void *arg) 238 { 239 struct rxe_bth *bth = arg; 240 241 return 0 != (cpu_to_be32(BTH_BECN_MASK) & bth->qpn); 242 } 243 244 static inline void __bth_set_becn(void *arg, int becn) 245 { 246 struct rxe_bth *bth = arg; 247 248 if (becn) 249 bth->qpn |= cpu_to_be32(BTH_BECN_MASK); 250 else 251 bth->qpn &= ~cpu_to_be32(BTH_BECN_MASK); 252 } 253 254 static inline u8 __bth_resv6a(void *arg) 255 { 256 struct rxe_bth *bth = arg; 257 258 return (BTH_RESV6A_MASK & be32_to_cpu(bth->qpn)) >> 24; 259 } 260 261 static inline void __bth_set_resv6a(void *arg) 262 { 263 struct rxe_bth *bth = arg; 264 265 bth->qpn = cpu_to_be32(~BTH_RESV6A_MASK); 266 } 267 268 static inline int __bth_ack(void *arg) 269 { 270 struct rxe_bth *bth = arg; 271 272 return 0 != (cpu_to_be32(BTH_ACK_MASK) & bth->apsn); 273 } 274 275 static inline void __bth_set_ack(void *arg, int ack) 276 { 277 struct rxe_bth *bth = arg; 278 279 if (ack) 280 bth->apsn |= cpu_to_be32(BTH_ACK_MASK); 281 else 282 bth->apsn &= ~cpu_to_be32(BTH_ACK_MASK); 283 } 284 285 static inline void __bth_set_resv7(void *arg) 286 { 287 struct rxe_bth *bth = arg; 288 289 bth->apsn &= ~cpu_to_be32(BTH_RESV7_MASK); 290 } 291 292 static inline u32 __bth_psn(void *arg) 293 { 294 struct rxe_bth *bth = arg; 295 296 return BTH_PSN_MASK & be32_to_cpu(bth->apsn); 297 } 298 299 static inline void __bth_set_psn(void *arg, u32 psn) 300 { 301 struct rxe_bth *bth = arg; 302 u32 apsn = be32_to_cpu(bth->apsn); 303 304 bth->apsn = cpu_to_be32((BTH_PSN_MASK & psn) | 305 (~BTH_PSN_MASK & apsn)); 306 } 307 308 static inline u8 bth_opcode(struct rxe_pkt_info *pkt) 309 { 310 return __bth_opcode(pkt->hdr + pkt->offset); 311 } 312 313 static inline void bth_set_opcode(struct rxe_pkt_info *pkt, u8 opcode) 314 { 315 __bth_set_opcode(pkt->hdr + pkt->offset, opcode); 316 } 317 318 static inline u8 bth_se(struct rxe_pkt_info *pkt) 319 { 320 return __bth_se(pkt->hdr + pkt->offset); 321 } 322 323 static inline void bth_set_se(struct rxe_pkt_info *pkt, int se) 324 { 325 __bth_set_se(pkt->hdr + pkt->offset, se); 326 } 327 328 static inline u8 bth_mig(struct rxe_pkt_info *pkt) 329 { 330 return __bth_mig(pkt->hdr + pkt->offset); 331 } 332 333 static inline void bth_set_mig(struct rxe_pkt_info *pkt, u8 mig) 334 { 335 __bth_set_mig(pkt->hdr + pkt->offset, mig); 336 } 337 338 static inline u8 bth_pad(struct rxe_pkt_info *pkt) 339 { 340 return __bth_pad(pkt->hdr + pkt->offset); 341 } 342 343 static inline void bth_set_pad(struct rxe_pkt_info *pkt, u8 pad) 344 { 345 __bth_set_pad(pkt->hdr + pkt->offset, pad); 346 } 347 348 static inline u8 bth_tver(struct rxe_pkt_info *pkt) 349 { 350 return __bth_tver(pkt->hdr + pkt->offset); 351 } 352 353 static inline void bth_set_tver(struct rxe_pkt_info *pkt, u8 tver) 354 { 355 __bth_set_tver(pkt->hdr + pkt->offset, tver); 356 } 357 358 static inline u16 bth_pkey(struct rxe_pkt_info *pkt) 359 { 360 return __bth_pkey(pkt->hdr + pkt->offset); 361 } 362 363 static inline void bth_set_pkey(struct rxe_pkt_info *pkt, u16 pkey) 364 { 365 __bth_set_pkey(pkt->hdr + pkt->offset, pkey); 366 } 367 368 static inline u32 bth_qpn(struct rxe_pkt_info *pkt) 369 { 370 return __bth_qpn(pkt->hdr + pkt->offset); 371 } 372 373 static inline void bth_set_qpn(struct rxe_pkt_info *pkt, u32 qpn) 374 { 375 __bth_set_qpn(pkt->hdr + pkt->offset, qpn); 376 } 377 378 static inline int bth_fecn(struct rxe_pkt_info *pkt) 379 { 380 return __bth_fecn(pkt->hdr + pkt->offset); 381 } 382 383 static inline void bth_set_fecn(struct rxe_pkt_info *pkt, int fecn) 384 { 385 __bth_set_fecn(pkt->hdr + pkt->offset, fecn); 386 } 387 388 static inline int bth_becn(struct rxe_pkt_info *pkt) 389 { 390 return __bth_becn(pkt->hdr + pkt->offset); 391 } 392 393 static inline void bth_set_becn(struct rxe_pkt_info *pkt, int becn) 394 { 395 __bth_set_becn(pkt->hdr + pkt->offset, becn); 396 } 397 398 static inline u8 bth_resv6a(struct rxe_pkt_info *pkt) 399 { 400 return __bth_resv6a(pkt->hdr + pkt->offset); 401 } 402 403 static inline void bth_set_resv6a(struct rxe_pkt_info *pkt) 404 { 405 __bth_set_resv6a(pkt->hdr + pkt->offset); 406 } 407 408 static inline int bth_ack(struct rxe_pkt_info *pkt) 409 { 410 return __bth_ack(pkt->hdr + pkt->offset); 411 } 412 413 static inline void bth_set_ack(struct rxe_pkt_info *pkt, int ack) 414 { 415 __bth_set_ack(pkt->hdr + pkt->offset, ack); 416 } 417 418 static inline void bth_set_resv7(struct rxe_pkt_info *pkt) 419 { 420 __bth_set_resv7(pkt->hdr + pkt->offset); 421 } 422 423 static inline u32 bth_psn(struct rxe_pkt_info *pkt) 424 { 425 return __bth_psn(pkt->hdr + pkt->offset); 426 } 427 428 static inline void bth_set_psn(struct rxe_pkt_info *pkt, u32 psn) 429 { 430 __bth_set_psn(pkt->hdr + pkt->offset, psn); 431 } 432 433 static inline void bth_init(struct rxe_pkt_info *pkt, u8 opcode, int se, 434 int mig, int pad, u16 pkey, u32 qpn, int ack_req, 435 u32 psn) 436 { 437 struct rxe_bth *bth = (struct rxe_bth *)(pkt->hdr + pkt->offset); 438 439 bth->opcode = opcode; 440 bth->flags = (pad << 4) & BTH_PAD_MASK; 441 if (se) 442 bth->flags |= BTH_SE_MASK; 443 if (mig) 444 bth->flags |= BTH_MIG_MASK; 445 bth->pkey = cpu_to_be16(pkey); 446 bth->qpn = cpu_to_be32(qpn & BTH_QPN_MASK); 447 psn &= BTH_PSN_MASK; 448 if (ack_req) 449 psn |= BTH_ACK_MASK; 450 bth->apsn = cpu_to_be32(psn); 451 } 452 453 /****************************************************************************** 454 * Reliable Datagram Extended Transport Header 455 ******************************************************************************/ 456 struct rxe_rdeth { 457 __be32 een; 458 }; 459 460 #define RDETH_EEN_MASK (0x00ffffff) 461 462 static inline u8 __rdeth_een(void *arg) 463 { 464 struct rxe_rdeth *rdeth = arg; 465 466 return RDETH_EEN_MASK & be32_to_cpu(rdeth->een); 467 } 468 469 static inline void __rdeth_set_een(void *arg, u32 een) 470 { 471 struct rxe_rdeth *rdeth = arg; 472 473 rdeth->een = cpu_to_be32(RDETH_EEN_MASK & een); 474 } 475 476 static inline u8 rdeth_een(struct rxe_pkt_info *pkt) 477 { 478 return __rdeth_een(pkt->hdr + pkt->offset 479 + rxe_opcode[pkt->opcode].offset[RXE_RDETH]); 480 } 481 482 static inline void rdeth_set_een(struct rxe_pkt_info *pkt, u32 een) 483 { 484 __rdeth_set_een(pkt->hdr + pkt->offset 485 + rxe_opcode[pkt->opcode].offset[RXE_RDETH], een); 486 } 487 488 /****************************************************************************** 489 * Datagram Extended Transport Header 490 ******************************************************************************/ 491 struct rxe_deth { 492 __be32 qkey; 493 __be32 sqp; 494 }; 495 496 #define GSI_QKEY (0x80010000) 497 #define DETH_SQP_MASK (0x00ffffff) 498 499 static inline u32 __deth_qkey(void *arg) 500 { 501 struct rxe_deth *deth = arg; 502 503 return be32_to_cpu(deth->qkey); 504 } 505 506 static inline void __deth_set_qkey(void *arg, u32 qkey) 507 { 508 struct rxe_deth *deth = arg; 509 510 deth->qkey = cpu_to_be32(qkey); 511 } 512 513 static inline u32 __deth_sqp(void *arg) 514 { 515 struct rxe_deth *deth = arg; 516 517 return DETH_SQP_MASK & be32_to_cpu(deth->sqp); 518 } 519 520 static inline void __deth_set_sqp(void *arg, u32 sqp) 521 { 522 struct rxe_deth *deth = arg; 523 524 deth->sqp = cpu_to_be32(DETH_SQP_MASK & sqp); 525 } 526 527 static inline u32 deth_qkey(struct rxe_pkt_info *pkt) 528 { 529 return __deth_qkey(pkt->hdr + pkt->offset 530 + rxe_opcode[pkt->opcode].offset[RXE_DETH]); 531 } 532 533 static inline void deth_set_qkey(struct rxe_pkt_info *pkt, u32 qkey) 534 { 535 __deth_set_qkey(pkt->hdr + pkt->offset 536 + rxe_opcode[pkt->opcode].offset[RXE_DETH], qkey); 537 } 538 539 static inline u32 deth_sqp(struct rxe_pkt_info *pkt) 540 { 541 return __deth_sqp(pkt->hdr + pkt->offset 542 + rxe_opcode[pkt->opcode].offset[RXE_DETH]); 543 } 544 545 static inline void deth_set_sqp(struct rxe_pkt_info *pkt, u32 sqp) 546 { 547 __deth_set_sqp(pkt->hdr + pkt->offset 548 + rxe_opcode[pkt->opcode].offset[RXE_DETH], sqp); 549 } 550 551 /****************************************************************************** 552 * RDMA Extended Transport Header 553 ******************************************************************************/ 554 struct rxe_reth { 555 __be64 va; 556 __be32 rkey; 557 __be32 len; 558 }; 559 560 static inline u64 __reth_va(void *arg) 561 { 562 struct rxe_reth *reth = arg; 563 564 return be64_to_cpu(reth->va); 565 } 566 567 static inline void __reth_set_va(void *arg, u64 va) 568 { 569 struct rxe_reth *reth = arg; 570 571 reth->va = cpu_to_be64(va); 572 } 573 574 static inline u32 __reth_rkey(void *arg) 575 { 576 struct rxe_reth *reth = arg; 577 578 return be32_to_cpu(reth->rkey); 579 } 580 581 static inline void __reth_set_rkey(void *arg, u32 rkey) 582 { 583 struct rxe_reth *reth = arg; 584 585 reth->rkey = cpu_to_be32(rkey); 586 } 587 588 static inline u32 __reth_len(void *arg) 589 { 590 struct rxe_reth *reth = arg; 591 592 return be32_to_cpu(reth->len); 593 } 594 595 static inline void __reth_set_len(void *arg, u32 len) 596 { 597 struct rxe_reth *reth = arg; 598 599 reth->len = cpu_to_be32(len); 600 } 601 602 static inline u64 reth_va(struct rxe_pkt_info *pkt) 603 { 604 return __reth_va(pkt->hdr + pkt->offset 605 + rxe_opcode[pkt->opcode].offset[RXE_RETH]); 606 } 607 608 static inline void reth_set_va(struct rxe_pkt_info *pkt, u64 va) 609 { 610 __reth_set_va(pkt->hdr + pkt->offset 611 + rxe_opcode[pkt->opcode].offset[RXE_RETH], va); 612 } 613 614 static inline u32 reth_rkey(struct rxe_pkt_info *pkt) 615 { 616 return __reth_rkey(pkt->hdr + pkt->offset 617 + rxe_opcode[pkt->opcode].offset[RXE_RETH]); 618 } 619 620 static inline void reth_set_rkey(struct rxe_pkt_info *pkt, u32 rkey) 621 { 622 __reth_set_rkey(pkt->hdr + pkt->offset 623 + rxe_opcode[pkt->opcode].offset[RXE_RETH], rkey); 624 } 625 626 static inline u32 reth_len(struct rxe_pkt_info *pkt) 627 { 628 return __reth_len(pkt->hdr + pkt->offset 629 + rxe_opcode[pkt->opcode].offset[RXE_RETH]); 630 } 631 632 static inline void reth_set_len(struct rxe_pkt_info *pkt, u32 len) 633 { 634 __reth_set_len(pkt->hdr + pkt->offset 635 + rxe_opcode[pkt->opcode].offset[RXE_RETH], len); 636 } 637 638 /****************************************************************************** 639 * Atomic Extended Transport Header 640 ******************************************************************************/ 641 struct rxe_atmeth { 642 __be64 va; 643 __be32 rkey; 644 __be64 swap_add; 645 __be64 comp; 646 } __attribute__((__packed__)); 647 648 static inline u64 __atmeth_va(void *arg) 649 { 650 struct rxe_atmeth *atmeth = arg; 651 652 return be64_to_cpu(atmeth->va); 653 } 654 655 static inline void __atmeth_set_va(void *arg, u64 va) 656 { 657 struct rxe_atmeth *atmeth = arg; 658 659 atmeth->va = cpu_to_be64(va); 660 } 661 662 static inline u32 __atmeth_rkey(void *arg) 663 { 664 struct rxe_atmeth *atmeth = arg; 665 666 return be32_to_cpu(atmeth->rkey); 667 } 668 669 static inline void __atmeth_set_rkey(void *arg, u32 rkey) 670 { 671 struct rxe_atmeth *atmeth = arg; 672 673 atmeth->rkey = cpu_to_be32(rkey); 674 } 675 676 static inline u64 __atmeth_swap_add(void *arg) 677 { 678 struct rxe_atmeth *atmeth = arg; 679 680 return be64_to_cpu(atmeth->swap_add); 681 } 682 683 static inline void __atmeth_set_swap_add(void *arg, u64 swap_add) 684 { 685 struct rxe_atmeth *atmeth = arg; 686 687 atmeth->swap_add = cpu_to_be64(swap_add); 688 } 689 690 static inline u64 __atmeth_comp(void *arg) 691 { 692 struct rxe_atmeth *atmeth = arg; 693 694 return be64_to_cpu(atmeth->comp); 695 } 696 697 static inline void __atmeth_set_comp(void *arg, u64 comp) 698 { 699 struct rxe_atmeth *atmeth = arg; 700 701 atmeth->comp = cpu_to_be64(comp); 702 } 703 704 static inline u64 atmeth_va(struct rxe_pkt_info *pkt) 705 { 706 return __atmeth_va(pkt->hdr + pkt->offset 707 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH]); 708 } 709 710 static inline void atmeth_set_va(struct rxe_pkt_info *pkt, u64 va) 711 { 712 __atmeth_set_va(pkt->hdr + pkt->offset 713 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH], va); 714 } 715 716 static inline u32 atmeth_rkey(struct rxe_pkt_info *pkt) 717 { 718 return __atmeth_rkey(pkt->hdr + pkt->offset 719 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH]); 720 } 721 722 static inline void atmeth_set_rkey(struct rxe_pkt_info *pkt, u32 rkey) 723 { 724 __atmeth_set_rkey(pkt->hdr + pkt->offset 725 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH], rkey); 726 } 727 728 static inline u64 atmeth_swap_add(struct rxe_pkt_info *pkt) 729 { 730 return __atmeth_swap_add(pkt->hdr + pkt->offset 731 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH]); 732 } 733 734 static inline void atmeth_set_swap_add(struct rxe_pkt_info *pkt, u64 swap_add) 735 { 736 __atmeth_set_swap_add(pkt->hdr + pkt->offset 737 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH], swap_add); 738 } 739 740 static inline u64 atmeth_comp(struct rxe_pkt_info *pkt) 741 { 742 return __atmeth_comp(pkt->hdr + pkt->offset 743 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH]); 744 } 745 746 static inline void atmeth_set_comp(struct rxe_pkt_info *pkt, u64 comp) 747 { 748 __atmeth_set_comp(pkt->hdr + pkt->offset 749 + rxe_opcode[pkt->opcode].offset[RXE_ATMETH], comp); 750 } 751 752 /****************************************************************************** 753 * Ack Extended Transport Header 754 ******************************************************************************/ 755 struct rxe_aeth { 756 __be32 smsn; 757 }; 758 759 #define AETH_SYN_MASK (0xff000000) 760 #define AETH_MSN_MASK (0x00ffffff) 761 762 enum aeth_syndrome { 763 AETH_TYPE_MASK = 0xe0, 764 AETH_ACK = 0x00, 765 AETH_RNR_NAK = 0x20, 766 AETH_RSVD = 0x40, 767 AETH_NAK = 0x60, 768 AETH_ACK_UNLIMITED = 0x1f, 769 AETH_NAK_PSN_SEQ_ERROR = 0x60, 770 AETH_NAK_INVALID_REQ = 0x61, 771 AETH_NAK_REM_ACC_ERR = 0x62, 772 AETH_NAK_REM_OP_ERR = 0x63, 773 AETH_NAK_INV_RD_REQ = 0x64, 774 }; 775 776 static inline u8 __aeth_syn(void *arg) 777 { 778 struct rxe_aeth *aeth = arg; 779 780 return (AETH_SYN_MASK & be32_to_cpu(aeth->smsn)) >> 24; 781 } 782 783 static inline void __aeth_set_syn(void *arg, u8 syn) 784 { 785 struct rxe_aeth *aeth = arg; 786 u32 smsn = be32_to_cpu(aeth->smsn); 787 788 aeth->smsn = cpu_to_be32((AETH_SYN_MASK & (syn << 24)) | 789 (~AETH_SYN_MASK & smsn)); 790 } 791 792 static inline u32 __aeth_msn(void *arg) 793 { 794 struct rxe_aeth *aeth = arg; 795 796 return AETH_MSN_MASK & be32_to_cpu(aeth->smsn); 797 } 798 799 static inline void __aeth_set_msn(void *arg, u32 msn) 800 { 801 struct rxe_aeth *aeth = arg; 802 u32 smsn = be32_to_cpu(aeth->smsn); 803 804 aeth->smsn = cpu_to_be32((AETH_MSN_MASK & msn) | 805 (~AETH_MSN_MASK & smsn)); 806 } 807 808 static inline u8 aeth_syn(struct rxe_pkt_info *pkt) 809 { 810 return __aeth_syn(pkt->hdr + pkt->offset 811 + rxe_opcode[pkt->opcode].offset[RXE_AETH]); 812 } 813 814 static inline void aeth_set_syn(struct rxe_pkt_info *pkt, u8 syn) 815 { 816 __aeth_set_syn(pkt->hdr + pkt->offset 817 + rxe_opcode[pkt->opcode].offset[RXE_AETH], syn); 818 } 819 820 static inline u32 aeth_msn(struct rxe_pkt_info *pkt) 821 { 822 return __aeth_msn(pkt->hdr + pkt->offset 823 + rxe_opcode[pkt->opcode].offset[RXE_AETH]); 824 } 825 826 static inline void aeth_set_msn(struct rxe_pkt_info *pkt, u32 msn) 827 { 828 __aeth_set_msn(pkt->hdr + pkt->offset 829 + rxe_opcode[pkt->opcode].offset[RXE_AETH], msn); 830 } 831 832 /****************************************************************************** 833 * Atomic Ack Extended Transport Header 834 ******************************************************************************/ 835 struct rxe_atmack { 836 __be64 orig; 837 }; 838 839 static inline u64 __atmack_orig(void *arg) 840 { 841 struct rxe_atmack *atmack = arg; 842 843 return be64_to_cpu(atmack->orig); 844 } 845 846 static inline void __atmack_set_orig(void *arg, u64 orig) 847 { 848 struct rxe_atmack *atmack = arg; 849 850 atmack->orig = cpu_to_be64(orig); 851 } 852 853 static inline u64 atmack_orig(struct rxe_pkt_info *pkt) 854 { 855 return __atmack_orig(pkt->hdr + pkt->offset 856 + rxe_opcode[pkt->opcode].offset[RXE_ATMACK]); 857 } 858 859 static inline void atmack_set_orig(struct rxe_pkt_info *pkt, u64 orig) 860 { 861 __atmack_set_orig(pkt->hdr + pkt->offset 862 + rxe_opcode[pkt->opcode].offset[RXE_ATMACK], orig); 863 } 864 865 /****************************************************************************** 866 * Immediate Extended Transport Header 867 ******************************************************************************/ 868 struct rxe_immdt { 869 __be32 imm; 870 }; 871 872 static inline __be32 __immdt_imm(void *arg) 873 { 874 struct rxe_immdt *immdt = arg; 875 876 return immdt->imm; 877 } 878 879 static inline void __immdt_set_imm(void *arg, __be32 imm) 880 { 881 struct rxe_immdt *immdt = arg; 882 883 immdt->imm = imm; 884 } 885 886 static inline __be32 immdt_imm(struct rxe_pkt_info *pkt) 887 { 888 return __immdt_imm(pkt->hdr + pkt->offset 889 + rxe_opcode[pkt->opcode].offset[RXE_IMMDT]); 890 } 891 892 static inline void immdt_set_imm(struct rxe_pkt_info *pkt, __be32 imm) 893 { 894 __immdt_set_imm(pkt->hdr + pkt->offset 895 + rxe_opcode[pkt->opcode].offset[RXE_IMMDT], imm); 896 } 897 898 /****************************************************************************** 899 * Invalidate Extended Transport Header 900 ******************************************************************************/ 901 struct rxe_ieth { 902 __be32 rkey; 903 }; 904 905 static inline u32 __ieth_rkey(void *arg) 906 { 907 struct rxe_ieth *ieth = arg; 908 909 return be32_to_cpu(ieth->rkey); 910 } 911 912 static inline void __ieth_set_rkey(void *arg, u32 rkey) 913 { 914 struct rxe_ieth *ieth = arg; 915 916 ieth->rkey = cpu_to_be32(rkey); 917 } 918 919 static inline u32 ieth_rkey(struct rxe_pkt_info *pkt) 920 { 921 return __ieth_rkey(pkt->hdr + pkt->offset 922 + rxe_opcode[pkt->opcode].offset[RXE_IETH]); 923 } 924 925 static inline void ieth_set_rkey(struct rxe_pkt_info *pkt, u32 rkey) 926 { 927 __ieth_set_rkey(pkt->hdr + pkt->offset 928 + rxe_opcode[pkt->opcode].offset[RXE_IETH], rkey); 929 } 930 931 enum rxe_hdr_length { 932 RXE_BTH_BYTES = sizeof(struct rxe_bth), 933 RXE_DETH_BYTES = sizeof(struct rxe_deth), 934 RXE_IMMDT_BYTES = sizeof(struct rxe_immdt), 935 RXE_RETH_BYTES = sizeof(struct rxe_reth), 936 RXE_AETH_BYTES = sizeof(struct rxe_aeth), 937 RXE_ATMACK_BYTES = sizeof(struct rxe_atmack), 938 RXE_ATMETH_BYTES = sizeof(struct rxe_atmeth), 939 RXE_IETH_BYTES = sizeof(struct rxe_ieth), 940 RXE_RDETH_BYTES = sizeof(struct rxe_rdeth), 941 }; 942 943 static inline size_t header_size(struct rxe_pkt_info *pkt) 944 { 945 return pkt->offset + rxe_opcode[pkt->opcode].length; 946 } 947 948 static inline void *payload_addr(struct rxe_pkt_info *pkt) 949 { 950 return pkt->hdr + pkt->offset 951 + rxe_opcode[pkt->opcode].offset[RXE_PAYLOAD]; 952 } 953 954 static inline size_t payload_size(struct rxe_pkt_info *pkt) 955 { 956 return pkt->paylen - rxe_opcode[pkt->opcode].offset[RXE_PAYLOAD] 957 - bth_pad(pkt) - RXE_ICRC_SIZE; 958 } 959 960 #endif /* RXE_HDR_H */ 961