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