xref: /linux/drivers/infiniband/sw/rxe/rxe_hdr.h (revision c7546e2c3cb739a3c1a2f5acaf9bb629d401afe5) 
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  */
14 struct 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 */
28 static 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 
34 static 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  ******************************************************************************/
61 struct 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 
84 static inline u8 __bth_opcode(void *arg)
85 {
86 	struct rxe_bth *bth = arg;
87 
88 	return bth->opcode;
89 }
90 
91 static inline void __bth_set_opcode(void *arg, u8 opcode)
92 {
93 	struct rxe_bth *bth = arg;
94 
95 	bth->opcode = opcode;
96 }
97 
98 static inline u8 __bth_se(void *arg)
99 {
100 	struct rxe_bth *bth = arg;
101 
102 	return 0 != (BTH_SE_MASK & bth->flags);
103 }
104 
105 static 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 
115 static inline u8 __bth_mig(void *arg)
116 {
117 	struct rxe_bth *bth = arg;
118 
119 	return 0 != (BTH_MIG_MASK & bth->flags);
120 }
121 
122 static 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 
132 static inline u8 __bth_pad(void *arg)
133 {
134 	struct rxe_bth *bth = arg;
135 
136 	return (BTH_PAD_MASK & bth->flags) >> 4;
137 }
138 
139 static 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 
147 static inline u8 __bth_tver(void *arg)
148 {
149 	struct rxe_bth *bth = arg;
150 
151 	return BTH_TVER_MASK & bth->flags;
152 }
153 
154 static 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 
162 static inline u16 __bth_pkey(void *arg)
163 {
164 	struct rxe_bth *bth = arg;
165 
166 	return be16_to_cpu(bth->pkey);
167 }
168 
169 static 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 
176 static 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 
183 static 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 
192 static 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 
199 static 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 
209 static 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 
216 static 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 
226 static 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 
233 static 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 
240 static 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 
247 static 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 
257 static 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 
264 static 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 
271 static 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 
280 static inline u8 bth_opcode(struct rxe_pkt_info *pkt)
281 {
282 	return __bth_opcode(pkt->hdr);
283 }
284 
285 static inline void bth_set_opcode(struct rxe_pkt_info *pkt, u8 opcode)
286 {
287 	__bth_set_opcode(pkt->hdr, opcode);
288 }
289 
290 static inline u8 bth_se(struct rxe_pkt_info *pkt)
291 {
292 	return __bth_se(pkt->hdr);
293 }
294 
295 static inline void bth_set_se(struct rxe_pkt_info *pkt, int se)
296 {
297 	__bth_set_se(pkt->hdr, se);
298 }
299 
300 static inline u8 bth_mig(struct rxe_pkt_info *pkt)
301 {
302 	return __bth_mig(pkt->hdr);
303 }
304 
305 static inline void bth_set_mig(struct rxe_pkt_info *pkt, u8 mig)
306 {
307 	__bth_set_mig(pkt->hdr, mig);
308 }
309 
310 static inline u8 bth_pad(struct rxe_pkt_info *pkt)
311 {
312 	return __bth_pad(pkt->hdr);
313 }
314 
315 static inline void bth_set_pad(struct rxe_pkt_info *pkt, u8 pad)
316 {
317 	__bth_set_pad(pkt->hdr, pad);
318 }
319 
320 static inline u8 bth_tver(struct rxe_pkt_info *pkt)
321 {
322 	return __bth_tver(pkt->hdr);
323 }
324 
325 static inline void bth_set_tver(struct rxe_pkt_info *pkt, u8 tver)
326 {
327 	__bth_set_tver(pkt->hdr, tver);
328 }
329 
330 static inline u16 bth_pkey(struct rxe_pkt_info *pkt)
331 {
332 	return __bth_pkey(pkt->hdr);
333 }
334 
335 static inline void bth_set_pkey(struct rxe_pkt_info *pkt, u16 pkey)
336 {
337 	__bth_set_pkey(pkt->hdr, pkey);
338 }
339 
340 static inline u32 bth_qpn(struct rxe_pkt_info *pkt)
341 {
342 	return __bth_qpn(pkt->hdr);
343 }
344 
345 static inline void bth_set_qpn(struct rxe_pkt_info *pkt, u32 qpn)
346 {
347 	__bth_set_qpn(pkt->hdr, qpn);
348 }
349 
350 static inline int bth_fecn(struct rxe_pkt_info *pkt)
351 {
352 	return __bth_fecn(pkt->hdr);
353 }
354 
355 static inline void bth_set_fecn(struct rxe_pkt_info *pkt, int fecn)
356 {
357 	__bth_set_fecn(pkt->hdr, fecn);
358 }
359 
360 static inline int bth_becn(struct rxe_pkt_info *pkt)
361 {
362 	return __bth_becn(pkt->hdr);
363 }
364 
365 static inline void bth_set_becn(struct rxe_pkt_info *pkt, int becn)
366 {
367 	__bth_set_becn(pkt->hdr, becn);
368 }
369 
370 static inline u8 bth_resv6a(struct rxe_pkt_info *pkt)
371 {
372 	return __bth_resv6a(pkt->hdr);
373 }
374 
375 static inline void bth_set_resv6a(struct rxe_pkt_info *pkt)
376 {
377 	__bth_set_resv6a(pkt->hdr);
378 }
379 
380 static inline int bth_ack(struct rxe_pkt_info *pkt)
381 {
382 	return __bth_ack(pkt->hdr);
383 }
384 
385 static inline void bth_set_ack(struct rxe_pkt_info *pkt, int ack)
386 {
387 	__bth_set_ack(pkt->hdr, ack);
388 }
389 
390 static inline void bth_set_resv7(struct rxe_pkt_info *pkt)
391 {
392 	__bth_set_resv7(pkt->hdr);
393 }
394 
395 static inline u32 bth_psn(struct rxe_pkt_info *pkt)
396 {
397 	return __bth_psn(pkt->hdr);
398 }
399 
400 static inline void bth_set_psn(struct rxe_pkt_info *pkt, u32 psn)
401 {
402 	__bth_set_psn(pkt->hdr, psn);
403 }
404 
405 static 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  ******************************************************************************/
428 struct rxe_rdeth {
429 	__be32			een;
430 };
431 
432 #define RDETH_EEN_MASK		(0x00ffffff)
433 
434 static 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 
441 static 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 
448 static 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 
454 static 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  ******************************************************************************/
463 struct rxe_deth {
464 	__be32			qkey;
465 	__be32			sqp;
466 };
467 
468 #define GSI_QKEY		(0x80010000)
469 #define DETH_SQP_MASK		(0x00ffffff)
470 
471 static inline u32 __deth_qkey(void *arg)
472 {
473 	struct rxe_deth *deth = arg;
474 
475 	return be32_to_cpu(deth->qkey);
476 }
477 
478 static 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 
485 static 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 
492 static 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 
499 static 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 
505 static 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 
511 static 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 
517 static 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  ******************************************************************************/
526 struct rxe_reth {
527 	__be64			va;
528 	__be32			rkey;
529 	__be32			len;
530 };
531 
532 static inline u64 __reth_va(void *arg)
533 {
534 	struct rxe_reth *reth = arg;
535 
536 	return be64_to_cpu(reth->va);
537 }
538 
539 static 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 
546 static inline u32 __reth_rkey(void *arg)
547 {
548 	struct rxe_reth *reth = arg;
549 
550 	return be32_to_cpu(reth->rkey);
551 }
552 
553 static 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 
560 static inline u32 __reth_len(void *arg)
561 {
562 	struct rxe_reth *reth = arg;
563 
564 	return be32_to_cpu(reth->len);
565 }
566 
567 static 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 
574 static 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 
580 static 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 
586 static 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 
592 static 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 
598 static 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 
604 static 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 
614 struct 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 
622 static 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 
629 static 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 
636 static 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 
641 static 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 
646 static 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  ******************************************************************************/
659 struct rxe_atmeth {
660 	__be64			va;
661 	__be32			rkey;
662 	__be64			swap_add;
663 	__be64			comp;
664 } __packed;
665 
666 static inline u64 __atmeth_va(void *arg)
667 {
668 	struct rxe_atmeth *atmeth = arg;
669 
670 	return be64_to_cpu(atmeth->va);
671 }
672 
673 static 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 
680 static inline u32 __atmeth_rkey(void *arg)
681 {
682 	struct rxe_atmeth *atmeth = arg;
683 
684 	return be32_to_cpu(atmeth->rkey);
685 }
686 
687 static 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 
694 static 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 
701 static 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 
708 static inline u64 __atmeth_comp(void *arg)
709 {
710 	struct rxe_atmeth *atmeth = arg;
711 
712 	return be64_to_cpu(atmeth->comp);
713 }
714 
715 static 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 
722 static 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 
728 static 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 
734 static 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 
740 static 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 
746 static 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 
752 static 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 
758 static 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 
764 static 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  ******************************************************************************/
773 struct rxe_aeth {
774 	__be32			smsn;
775 };
776 
777 #define AETH_SYN_MASK		(0xff000000)
778 #define AETH_MSN_MASK		(0x00ffffff)
779 
780 enum 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 
793 static 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 
800 static 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 
809 static 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 
816 static 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 
825 static 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 
831 static 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 
837 static 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 
843 static 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  ******************************************************************************/
852 struct rxe_atmack {
853 	__be64			orig;
854 };
855 
856 static inline u64 __atmack_orig(void *arg)
857 {
858 	struct rxe_atmack *atmack = arg;
859 
860 	return be64_to_cpu(atmack->orig);
861 }
862 
863 static 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 
870 static 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 
876 static 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  ******************************************************************************/
885 struct rxe_immdt {
886 	__be32			imm;
887 };
888 
889 static inline __be32 __immdt_imm(void *arg)
890 {
891 	struct rxe_immdt *immdt = arg;
892 
893 	return immdt->imm;
894 }
895 
896 static inline void __immdt_set_imm(void *arg, __be32 imm)
897 {
898 	struct rxe_immdt *immdt = arg;
899 
900 	immdt->imm = imm;
901 }
902 
903 static 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 
909 static 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  ******************************************************************************/
918 struct rxe_ieth {
919 	__be32			rkey;
920 };
921 
922 static inline u32 __ieth_rkey(void *arg)
923 {
924 	struct rxe_ieth *ieth = arg;
925 
926 	return be32_to_cpu(ieth->rkey);
927 }
928 
929 static 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 
936 static 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 
942 static 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 
948 enum 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 
961 static inline size_t header_size(struct rxe_pkt_info *pkt)
962 {
963 	return rxe_opcode[pkt->opcode].length;
964 }
965 
966 static inline void *payload_addr(struct rxe_pkt_info *pkt)
967 {
968 	return pkt->hdr + rxe_opcode[pkt->opcode].offset[RXE_PAYLOAD];
969 }
970 
971 static 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