Merge tag 'sunxi-dt64-for-4.21-2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / include / soc / fsl / dpaa2-fd.h
1 /* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
2 /*
3  * Copyright 2014-2016 Freescale Semiconductor Inc.
4  * Copyright 2016 NXP
5  *
6  */
7 #ifndef __FSL_DPAA2_FD_H
8 #define __FSL_DPAA2_FD_H
9
10 #include <linux/kernel.h>
11
12 /**
13  * DOC: DPAA2 FD - Frame Descriptor APIs for DPAA2
14  *
15  * Frame Descriptors (FDs) are used to describe frame data in the DPAA2.
16  * Frames can be enqueued and dequeued to Frame Queues (FQs) which are consumed
17  * by the various DPAA accelerators (WRIOP, SEC, PME, DCE)
18  *
19  * There are three types of frames: single, scatter gather, and frame lists.
20  *
21  * The set of APIs in this file must be used to create, manipulate and
22  * query Frame Descriptors.
23  */
24
25 /**
26  * struct dpaa2_fd - Struct describing FDs
27  * @words:         for easier/faster copying the whole FD structure
28  * @addr:          address in the FD
29  * @len:           length in the FD
30  * @bpid:          buffer pool ID
31  * @format_offset: format, offset, and short-length fields
32  * @frc:           frame context
33  * @ctrl:          control bits...including dd, sc, va, err, etc
34  * @flc:           flow context address
35  *
36  * This structure represents the basic Frame Descriptor used in the system.
37  */
38 struct dpaa2_fd {
39         union {
40                 u32 words[8];
41                 struct dpaa2_fd_simple {
42                         __le64 addr;
43                         __le32 len;
44                         __le16 bpid;
45                         __le16 format_offset;
46                         __le32 frc;
47                         __le32 ctrl;
48                         __le64 flc;
49                 } simple;
50         };
51 };
52
53 #define FD_SHORT_LEN_FLAG_MASK  0x1
54 #define FD_SHORT_LEN_FLAG_SHIFT 14
55 #define FD_SHORT_LEN_MASK       0x3FFFF
56 #define FD_OFFSET_MASK          0x0FFF
57 #define FD_FORMAT_MASK          0x3
58 #define FD_FORMAT_SHIFT         12
59 #define FD_BPID_MASK            0x3FFF
60 #define SG_SHORT_LEN_FLAG_MASK  0x1
61 #define SG_SHORT_LEN_FLAG_SHIFT 14
62 #define SG_SHORT_LEN_MASK       0x1FFFF
63 #define SG_OFFSET_MASK          0x0FFF
64 #define SG_FORMAT_MASK          0x3
65 #define SG_FORMAT_SHIFT         12
66 #define SG_BPID_MASK            0x3FFF
67 #define SG_FINAL_FLAG_MASK      0x1
68 #define SG_FINAL_FLAG_SHIFT     15
69 #define FL_SHORT_LEN_FLAG_MASK  0x1
70 #define FL_SHORT_LEN_FLAG_SHIFT 14
71 #define FL_SHORT_LEN_MASK       0x3FFFF
72 #define FL_OFFSET_MASK          0x0FFF
73 #define FL_FORMAT_MASK          0x3
74 #define FL_FORMAT_SHIFT         12
75 #define FL_BPID_MASK            0x3FFF
76 #define FL_FINAL_FLAG_MASK      0x1
77 #define FL_FINAL_FLAG_SHIFT     15
78
79 /* Error bits in FD CTRL */
80 #define FD_CTRL_ERR_MASK        0x000000FF
81 #define FD_CTRL_UFD             0x00000004
82 #define FD_CTRL_SBE             0x00000008
83 #define FD_CTRL_FLC             0x00000010
84 #define FD_CTRL_FSE             0x00000020
85 #define FD_CTRL_FAERR           0x00000040
86
87 /* Annotation bits in FD CTRL */
88 #define FD_CTRL_PTA             0x00800000
89 #define FD_CTRL_PTV1            0x00400000
90
91 enum dpaa2_fd_format {
92         dpaa2_fd_single = 0,
93         dpaa2_fd_list,
94         dpaa2_fd_sg
95 };
96
97 /**
98  * dpaa2_fd_get_addr() - get the addr field of frame descriptor
99  * @fd: the given frame descriptor
100  *
101  * Return the address in the frame descriptor.
102  */
103 static inline dma_addr_t dpaa2_fd_get_addr(const struct dpaa2_fd *fd)
104 {
105         return (dma_addr_t)le64_to_cpu(fd->simple.addr);
106 }
107
108 /**
109  * dpaa2_fd_set_addr() - Set the addr field of frame descriptor
110  * @fd: the given frame descriptor
111  * @addr: the address needs to be set in frame descriptor
112  */
113 static inline void dpaa2_fd_set_addr(struct dpaa2_fd *fd, dma_addr_t addr)
114 {
115         fd->simple.addr = cpu_to_le64(addr);
116 }
117
118 /**
119  * dpaa2_fd_get_frc() - Get the frame context in the frame descriptor
120  * @fd: the given frame descriptor
121  *
122  * Return the frame context field in the frame descriptor.
123  */
124 static inline u32 dpaa2_fd_get_frc(const struct dpaa2_fd *fd)
125 {
126         return le32_to_cpu(fd->simple.frc);
127 }
128
129 /**
130  * dpaa2_fd_set_frc() - Set the frame context in the frame descriptor
131  * @fd: the given frame descriptor
132  * @frc: the frame context needs to be set in frame descriptor
133  */
134 static inline void dpaa2_fd_set_frc(struct dpaa2_fd *fd, u32 frc)
135 {
136         fd->simple.frc = cpu_to_le32(frc);
137 }
138
139 /**
140  * dpaa2_fd_get_ctrl() - Get the control bits in the frame descriptor
141  * @fd: the given frame descriptor
142  *
143  * Return the control bits field in the frame descriptor.
144  */
145 static inline u32 dpaa2_fd_get_ctrl(const struct dpaa2_fd *fd)
146 {
147         return le32_to_cpu(fd->simple.ctrl);
148 }
149
150 /**
151  * dpaa2_fd_set_ctrl() - Set the control bits in the frame descriptor
152  * @fd: the given frame descriptor
153  * @ctrl: the control bits to be set in the frame descriptor
154  */
155 static inline void dpaa2_fd_set_ctrl(struct dpaa2_fd *fd, u32 ctrl)
156 {
157         fd->simple.ctrl = cpu_to_le32(ctrl);
158 }
159
160 /**
161  * dpaa2_fd_get_flc() - Get the flow context in the frame descriptor
162  * @fd: the given frame descriptor
163  *
164  * Return the flow context in the frame descriptor.
165  */
166 static inline dma_addr_t dpaa2_fd_get_flc(const struct dpaa2_fd *fd)
167 {
168         return (dma_addr_t)le64_to_cpu(fd->simple.flc);
169 }
170
171 /**
172  * dpaa2_fd_set_flc() - Set the flow context field of frame descriptor
173  * @fd: the given frame descriptor
174  * @flc_addr: the flow context needs to be set in frame descriptor
175  */
176 static inline void dpaa2_fd_set_flc(struct dpaa2_fd *fd,  dma_addr_t flc_addr)
177 {
178         fd->simple.flc = cpu_to_le64(flc_addr);
179 }
180
181 static inline bool dpaa2_fd_short_len(const struct dpaa2_fd *fd)
182 {
183         return !!((le16_to_cpu(fd->simple.format_offset) >>
184                   FD_SHORT_LEN_FLAG_SHIFT) & FD_SHORT_LEN_FLAG_MASK);
185 }
186
187 /**
188  * dpaa2_fd_get_len() - Get the length in the frame descriptor
189  * @fd: the given frame descriptor
190  *
191  * Return the length field in the frame descriptor.
192  */
193 static inline u32 dpaa2_fd_get_len(const struct dpaa2_fd *fd)
194 {
195         if (dpaa2_fd_short_len(fd))
196                 return le32_to_cpu(fd->simple.len) & FD_SHORT_LEN_MASK;
197
198         return le32_to_cpu(fd->simple.len);
199 }
200
201 /**
202  * dpaa2_fd_set_len() - Set the length field of frame descriptor
203  * @fd: the given frame descriptor
204  * @len: the length needs to be set in frame descriptor
205  */
206 static inline void dpaa2_fd_set_len(struct dpaa2_fd *fd, u32 len)
207 {
208         fd->simple.len = cpu_to_le32(len);
209 }
210
211 /**
212  * dpaa2_fd_get_offset() - Get the offset field in the frame descriptor
213  * @fd: the given frame descriptor
214  *
215  * Return the offset.
216  */
217 static inline uint16_t dpaa2_fd_get_offset(const struct dpaa2_fd *fd)
218 {
219         return le16_to_cpu(fd->simple.format_offset) & FD_OFFSET_MASK;
220 }
221
222 /**
223  * dpaa2_fd_set_offset() - Set the offset field of frame descriptor
224  * @fd: the given frame descriptor
225  * @offset: the offset needs to be set in frame descriptor
226  */
227 static inline void dpaa2_fd_set_offset(struct dpaa2_fd *fd, uint16_t offset)
228 {
229         fd->simple.format_offset &= cpu_to_le16(~FD_OFFSET_MASK);
230         fd->simple.format_offset |= cpu_to_le16(offset);
231 }
232
233 /**
234  * dpaa2_fd_get_format() - Get the format field in the frame descriptor
235  * @fd: the given frame descriptor
236  *
237  * Return the format.
238  */
239 static inline enum dpaa2_fd_format dpaa2_fd_get_format(
240                                                 const struct dpaa2_fd *fd)
241 {
242         return (enum dpaa2_fd_format)((le16_to_cpu(fd->simple.format_offset)
243                                       >> FD_FORMAT_SHIFT) & FD_FORMAT_MASK);
244 }
245
246 /**
247  * dpaa2_fd_set_format() - Set the format field of frame descriptor
248  * @fd: the given frame descriptor
249  * @format: the format needs to be set in frame descriptor
250  */
251 static inline void dpaa2_fd_set_format(struct dpaa2_fd *fd,
252                                        enum dpaa2_fd_format format)
253 {
254         fd->simple.format_offset &=
255                 cpu_to_le16(~(FD_FORMAT_MASK << FD_FORMAT_SHIFT));
256         fd->simple.format_offset |= cpu_to_le16(format << FD_FORMAT_SHIFT);
257 }
258
259 /**
260  * dpaa2_fd_get_bpid() - Get the bpid field in the frame descriptor
261  * @fd: the given frame descriptor
262  *
263  * Return the buffer pool id.
264  */
265 static inline uint16_t dpaa2_fd_get_bpid(const struct dpaa2_fd *fd)
266 {
267         return le16_to_cpu(fd->simple.bpid) & FD_BPID_MASK;
268 }
269
270 /**
271  * dpaa2_fd_set_bpid() - Set the bpid field of frame descriptor
272  * @fd: the given frame descriptor
273  * @bpid: buffer pool id to be set
274  */
275 static inline void dpaa2_fd_set_bpid(struct dpaa2_fd *fd, uint16_t bpid)
276 {
277         fd->simple.bpid &= cpu_to_le16(~(FD_BPID_MASK));
278         fd->simple.bpid |= cpu_to_le16(bpid);
279 }
280
281 /**
282  * struct dpaa2_sg_entry - the scatter-gathering structure
283  * @addr: address of the sg entry
284  * @len: length in this sg entry
285  * @bpid: buffer pool id
286  * @format_offset: format and offset fields
287  */
288 struct dpaa2_sg_entry {
289         __le64 addr;
290         __le32 len;
291         __le16 bpid;
292         __le16 format_offset;
293 };
294
295 enum dpaa2_sg_format {
296         dpaa2_sg_single = 0,
297         dpaa2_sg_frame_data,
298         dpaa2_sg_sgt_ext
299 };
300
301 /* Accessors for SG entry fields */
302
303 /**
304  * dpaa2_sg_get_addr() - Get the address from SG entry
305  * @sg: the given scatter-gathering object
306  *
307  * Return the address.
308  */
309 static inline dma_addr_t dpaa2_sg_get_addr(const struct dpaa2_sg_entry *sg)
310 {
311         return (dma_addr_t)le64_to_cpu(sg->addr);
312 }
313
314 /**
315  * dpaa2_sg_set_addr() - Set the address in SG entry
316  * @sg: the given scatter-gathering object
317  * @addr: the address to be set
318  */
319 static inline void dpaa2_sg_set_addr(struct dpaa2_sg_entry *sg, dma_addr_t addr)
320 {
321         sg->addr = cpu_to_le64(addr);
322 }
323
324 static inline bool dpaa2_sg_short_len(const struct dpaa2_sg_entry *sg)
325 {
326         return !!((le16_to_cpu(sg->format_offset) >> SG_SHORT_LEN_FLAG_SHIFT)
327                 & SG_SHORT_LEN_FLAG_MASK);
328 }
329
330 /**
331  * dpaa2_sg_get_len() - Get the length in SG entry
332  * @sg: the given scatter-gathering object
333  *
334  * Return the length.
335  */
336 static inline u32 dpaa2_sg_get_len(const struct dpaa2_sg_entry *sg)
337 {
338         if (dpaa2_sg_short_len(sg))
339                 return le32_to_cpu(sg->len) & SG_SHORT_LEN_MASK;
340
341         return le32_to_cpu(sg->len);
342 }
343
344 /**
345  * dpaa2_sg_set_len() - Set the length in SG entry
346  * @sg: the given scatter-gathering object
347  * @len: the length to be set
348  */
349 static inline void dpaa2_sg_set_len(struct dpaa2_sg_entry *sg, u32 len)
350 {
351         sg->len = cpu_to_le32(len);
352 }
353
354 /**
355  * dpaa2_sg_get_offset() - Get the offset in SG entry
356  * @sg: the given scatter-gathering object
357  *
358  * Return the offset.
359  */
360 static inline u16 dpaa2_sg_get_offset(const struct dpaa2_sg_entry *sg)
361 {
362         return le16_to_cpu(sg->format_offset) & SG_OFFSET_MASK;
363 }
364
365 /**
366  * dpaa2_sg_set_offset() - Set the offset in SG entry
367  * @sg: the given scatter-gathering object
368  * @offset: the offset to be set
369  */
370 static inline void dpaa2_sg_set_offset(struct dpaa2_sg_entry *sg,
371                                        u16 offset)
372 {
373         sg->format_offset &= cpu_to_le16(~SG_OFFSET_MASK);
374         sg->format_offset |= cpu_to_le16(offset);
375 }
376
377 /**
378  * dpaa2_sg_get_format() - Get the SG format in SG entry
379  * @sg: the given scatter-gathering object
380  *
381  * Return the format.
382  */
383 static inline enum dpaa2_sg_format
384         dpaa2_sg_get_format(const struct dpaa2_sg_entry *sg)
385 {
386         return (enum dpaa2_sg_format)((le16_to_cpu(sg->format_offset)
387                                        >> SG_FORMAT_SHIFT) & SG_FORMAT_MASK);
388 }
389
390 /**
391  * dpaa2_sg_set_format() - Set the SG format in SG entry
392  * @sg: the given scatter-gathering object
393  * @format: the format to be set
394  */
395 static inline void dpaa2_sg_set_format(struct dpaa2_sg_entry *sg,
396                                        enum dpaa2_sg_format format)
397 {
398         sg->format_offset &= cpu_to_le16(~(SG_FORMAT_MASK << SG_FORMAT_SHIFT));
399         sg->format_offset |= cpu_to_le16(format << SG_FORMAT_SHIFT);
400 }
401
402 /**
403  * dpaa2_sg_get_bpid() - Get the buffer pool id in SG entry
404  * @sg: the given scatter-gathering object
405  *
406  * Return the bpid.
407  */
408 static inline u16 dpaa2_sg_get_bpid(const struct dpaa2_sg_entry *sg)
409 {
410         return le16_to_cpu(sg->bpid) & SG_BPID_MASK;
411 }
412
413 /**
414  * dpaa2_sg_set_bpid() - Set the buffer pool id in SG entry
415  * @sg: the given scatter-gathering object
416  * @bpid: the bpid to be set
417  */
418 static inline void dpaa2_sg_set_bpid(struct dpaa2_sg_entry *sg, u16 bpid)
419 {
420         sg->bpid &= cpu_to_le16(~(SG_BPID_MASK));
421         sg->bpid |= cpu_to_le16(bpid);
422 }
423
424 /**
425  * dpaa2_sg_is_final() - Check final bit in SG entry
426  * @sg: the given scatter-gathering object
427  *
428  * Return bool.
429  */
430 static inline bool dpaa2_sg_is_final(const struct dpaa2_sg_entry *sg)
431 {
432         return !!(le16_to_cpu(sg->format_offset) >> SG_FINAL_FLAG_SHIFT);
433 }
434
435 /**
436  * dpaa2_sg_set_final() - Set the final bit in SG entry
437  * @sg: the given scatter-gathering object
438  * @final: the final boolean to be set
439  */
440 static inline void dpaa2_sg_set_final(struct dpaa2_sg_entry *sg, bool final)
441 {
442         sg->format_offset &= cpu_to_le16((~(SG_FINAL_FLAG_MASK
443                                          << SG_FINAL_FLAG_SHIFT)) & 0xFFFF);
444         sg->format_offset |= cpu_to_le16(final << SG_FINAL_FLAG_SHIFT);
445 }
446
447 /**
448  * struct dpaa2_fl_entry - structure for frame list entry.
449  * @addr:          address in the FLE
450  * @len:           length in the FLE
451  * @bpid:          buffer pool ID
452  * @format_offset: format, offset, and short-length fields
453  * @frc:           frame context
454  * @ctrl:          control bits...including pta, pvt1, pvt2, err, etc
455  * @flc:           flow context address
456  */
457 struct dpaa2_fl_entry {
458         __le64 addr;
459         __le32 len;
460         __le16 bpid;
461         __le16 format_offset;
462         __le32 frc;
463         __le32 ctrl;
464         __le64 flc;
465 };
466
467 enum dpaa2_fl_format {
468         dpaa2_fl_single = 0,
469         dpaa2_fl_res,
470         dpaa2_fl_sg
471 };
472
473 /**
474  * dpaa2_fl_get_addr() - get the addr field of FLE
475  * @fle: the given frame list entry
476  *
477  * Return the address in the frame list entry.
478  */
479 static inline dma_addr_t dpaa2_fl_get_addr(const struct dpaa2_fl_entry *fle)
480 {
481         return (dma_addr_t)le64_to_cpu(fle->addr);
482 }
483
484 /**
485  * dpaa2_fl_set_addr() - Set the addr field of FLE
486  * @fle: the given frame list entry
487  * @addr: the address needs to be set in frame list entry
488  */
489 static inline void dpaa2_fl_set_addr(struct dpaa2_fl_entry *fle,
490                                      dma_addr_t addr)
491 {
492         fle->addr = cpu_to_le64(addr);
493 }
494
495 /**
496  * dpaa2_fl_get_frc() - Get the frame context in the FLE
497  * @fle: the given frame list entry
498  *
499  * Return the frame context field in the frame lsit entry.
500  */
501 static inline u32 dpaa2_fl_get_frc(const struct dpaa2_fl_entry *fle)
502 {
503         return le32_to_cpu(fle->frc);
504 }
505
506 /**
507  * dpaa2_fl_set_frc() - Set the frame context in the FLE
508  * @fle: the given frame list entry
509  * @frc: the frame context needs to be set in frame list entry
510  */
511 static inline void dpaa2_fl_set_frc(struct dpaa2_fl_entry *fle, u32 frc)
512 {
513         fle->frc = cpu_to_le32(frc);
514 }
515
516 /**
517  * dpaa2_fl_get_ctrl() - Get the control bits in the FLE
518  * @fle: the given frame list entry
519  *
520  * Return the control bits field in the frame list entry.
521  */
522 static inline u32 dpaa2_fl_get_ctrl(const struct dpaa2_fl_entry *fle)
523 {
524         return le32_to_cpu(fle->ctrl);
525 }
526
527 /**
528  * dpaa2_fl_set_ctrl() - Set the control bits in the FLE
529  * @fle: the given frame list entry
530  * @ctrl: the control bits to be set in the frame list entry
531  */
532 static inline void dpaa2_fl_set_ctrl(struct dpaa2_fl_entry *fle, u32 ctrl)
533 {
534         fle->ctrl = cpu_to_le32(ctrl);
535 }
536
537 /**
538  * dpaa2_fl_get_flc() - Get the flow context in the FLE
539  * @fle: the given frame list entry
540  *
541  * Return the flow context in the frame list entry.
542  */
543 static inline dma_addr_t dpaa2_fl_get_flc(const struct dpaa2_fl_entry *fle)
544 {
545         return (dma_addr_t)le64_to_cpu(fle->flc);
546 }
547
548 /**
549  * dpaa2_fl_set_flc() - Set the flow context field of FLE
550  * @fle: the given frame list entry
551  * @flc_addr: the flow context needs to be set in frame list entry
552  */
553 static inline void dpaa2_fl_set_flc(struct dpaa2_fl_entry *fle,
554                                     dma_addr_t flc_addr)
555 {
556         fle->flc = cpu_to_le64(flc_addr);
557 }
558
559 static inline bool dpaa2_fl_short_len(const struct dpaa2_fl_entry *fle)
560 {
561         return !!((le16_to_cpu(fle->format_offset) >>
562                   FL_SHORT_LEN_FLAG_SHIFT) & FL_SHORT_LEN_FLAG_MASK);
563 }
564
565 /**
566  * dpaa2_fl_get_len() - Get the length in the FLE
567  * @fle: the given frame list entry
568  *
569  * Return the length field in the frame list entry.
570  */
571 static inline u32 dpaa2_fl_get_len(const struct dpaa2_fl_entry *fle)
572 {
573         if (dpaa2_fl_short_len(fle))
574                 return le32_to_cpu(fle->len) & FL_SHORT_LEN_MASK;
575
576         return le32_to_cpu(fle->len);
577 }
578
579 /**
580  * dpaa2_fl_set_len() - Set the length field of FLE
581  * @fle: the given frame list entry
582  * @len: the length needs to be set in frame list entry
583  */
584 static inline void dpaa2_fl_set_len(struct dpaa2_fl_entry *fle, u32 len)
585 {
586         fle->len = cpu_to_le32(len);
587 }
588
589 /**
590  * dpaa2_fl_get_offset() - Get the offset field in the frame list entry
591  * @fle: the given frame list entry
592  *
593  * Return the offset.
594  */
595 static inline u16 dpaa2_fl_get_offset(const struct dpaa2_fl_entry *fle)
596 {
597         return le16_to_cpu(fle->format_offset) & FL_OFFSET_MASK;
598 }
599
600 /**
601  * dpaa2_fl_set_offset() - Set the offset field of FLE
602  * @fle: the given frame list entry
603  * @offset: the offset needs to be set in frame list entry
604  */
605 static inline void dpaa2_fl_set_offset(struct dpaa2_fl_entry *fle, u16 offset)
606 {
607         fle->format_offset &= cpu_to_le16(~FL_OFFSET_MASK);
608         fle->format_offset |= cpu_to_le16(offset);
609 }
610
611 /**
612  * dpaa2_fl_get_format() - Get the format field in the FLE
613  * @fle: the given frame list entry
614  *
615  * Return the format.
616  */
617 static inline enum dpaa2_fl_format dpaa2_fl_get_format(const struct dpaa2_fl_entry *fle)
618 {
619         return (enum dpaa2_fl_format)((le16_to_cpu(fle->format_offset) >>
620                                        FL_FORMAT_SHIFT) & FL_FORMAT_MASK);
621 }
622
623 /**
624  * dpaa2_fl_set_format() - Set the format field of FLE
625  * @fle: the given frame list entry
626  * @format: the format needs to be set in frame list entry
627  */
628 static inline void dpaa2_fl_set_format(struct dpaa2_fl_entry *fle,
629                                        enum dpaa2_fl_format format)
630 {
631         fle->format_offset &= cpu_to_le16(~(FL_FORMAT_MASK << FL_FORMAT_SHIFT));
632         fle->format_offset |= cpu_to_le16(format << FL_FORMAT_SHIFT);
633 }
634
635 /**
636  * dpaa2_fl_get_bpid() - Get the bpid field in the FLE
637  * @fle: the given frame list entry
638  *
639  * Return the buffer pool id.
640  */
641 static inline u16 dpaa2_fl_get_bpid(const struct dpaa2_fl_entry *fle)
642 {
643         return le16_to_cpu(fle->bpid) & FL_BPID_MASK;
644 }
645
646 /**
647  * dpaa2_fl_set_bpid() - Set the bpid field of FLE
648  * @fle: the given frame list entry
649  * @bpid: buffer pool id to be set
650  */
651 static inline void dpaa2_fl_set_bpid(struct dpaa2_fl_entry *fle, u16 bpid)
652 {
653         fle->bpid &= cpu_to_le16(~(FL_BPID_MASK));
654         fle->bpid |= cpu_to_le16(bpid);
655 }
656
657 /**
658  * dpaa2_fl_is_final() - Check final bit in FLE
659  * @fle: the given frame list entry
660  *
661  * Return bool.
662  */
663 static inline bool dpaa2_fl_is_final(const struct dpaa2_fl_entry *fle)
664 {
665         return !!(le16_to_cpu(fle->format_offset) >> FL_FINAL_FLAG_SHIFT);
666 }
667
668 /**
669  * dpaa2_fl_set_final() - Set the final bit in FLE
670  * @fle: the given frame list entry
671  * @final: the final boolean to be set
672  */
673 static inline void dpaa2_fl_set_final(struct dpaa2_fl_entry *fle, bool final)
674 {
675         fle->format_offset &= cpu_to_le16((~(FL_FINAL_FLAG_MASK <<
676                                              FL_FINAL_FLAG_SHIFT)) & 0xFFFF);
677         fle->format_offset |= cpu_to_le16(final << FL_FINAL_FLAG_SHIFT);
678 }
679
680 #endif /* __FSL_DPAA2_FD_H */