This source file includes following definitions.
- SKB_TO_PKT
- PKT_TO_SKB
- __bth_opcode
- __bth_set_opcode
- __bth_se
- __bth_set_se
- __bth_mig
- __bth_set_mig
- __bth_pad
- __bth_set_pad
- __bth_tver
- __bth_set_tver
- __bth_pkey
- __bth_set_pkey
- __bth_qpn
- __bth_set_qpn
- __bth_fecn
- __bth_set_fecn
- __bth_becn
- __bth_set_becn
- __bth_resv6a
- __bth_set_resv6a
- __bth_ack
- __bth_set_ack
- __bth_set_resv7
- __bth_psn
- __bth_set_psn
- bth_opcode
- bth_set_opcode
- bth_se
- bth_set_se
- bth_mig
- bth_set_mig
- bth_pad
- bth_set_pad
- bth_tver
- bth_set_tver
- bth_pkey
- bth_set_pkey
- bth_qpn
- bth_set_qpn
- bth_fecn
- bth_set_fecn
- bth_becn
- bth_set_becn
- bth_resv6a
- bth_set_resv6a
- bth_ack
- bth_set_ack
- bth_set_resv7
- bth_psn
- bth_set_psn
- bth_init
- __rdeth_een
- __rdeth_set_een
- rdeth_een
- rdeth_set_een
- __deth_qkey
- __deth_set_qkey
- __deth_sqp
- __deth_set_sqp
- deth_qkey
- deth_set_qkey
- deth_sqp
- deth_set_sqp
- __reth_va
- __reth_set_va
- __reth_rkey
- __reth_set_rkey
- __reth_len
- __reth_set_len
- reth_va
- reth_set_va
- reth_rkey
- reth_set_rkey
- reth_len
- reth_set_len
- __atmeth_va
- __atmeth_set_va
- __atmeth_rkey
- __atmeth_set_rkey
- __atmeth_swap_add
- __atmeth_set_swap_add
- __atmeth_comp
- __atmeth_set_comp
- atmeth_va
- atmeth_set_va
- atmeth_rkey
- atmeth_set_rkey
- atmeth_swap_add
- atmeth_set_swap_add
- atmeth_comp
- atmeth_set_comp
- __aeth_syn
- __aeth_set_syn
- __aeth_msn
- __aeth_set_msn
- aeth_syn
- aeth_set_syn
- aeth_msn
- aeth_set_msn
- __atmack_orig
- __atmack_set_orig
- atmack_orig
- atmack_set_orig
- __immdt_imm
- __immdt_set_imm
- immdt_imm
- immdt_set_imm
- __ieth_rkey
- __ieth_set_rkey
- ieth_rkey
- ieth_set_rkey
- header_size
- payload_addr
- payload_size
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 #ifndef RXE_HDR_H
35 #define RXE_HDR_H
36
37
38
39
40
41 struct rxe_pkt_info {
42 struct rxe_dev *rxe;
43 struct rxe_qp *qp;
44 struct rxe_send_wqe *wqe;
45 u8 *hdr;
46 u32 mask;
47 u32 psn;
48 u16 pkey_index;
49 u16 paylen;
50 u8 port_num;
51 u8 opcode;
52 u8 offset;
53 };
54
55
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83 #define RXE_ICRC_SIZE (4)
84 #define RXE_MAX_HDR_LENGTH (80)
85
86
87
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
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
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
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
640
641 struct rxe_atmeth {
642 __be64 va;
643 __be32 rkey;
644 __be64 swap_add;
645 __be64 comp;
646 } __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
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
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
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
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