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 */
dpaa2_fd_get_addr(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_addr(struct dpaa2_fd * fd,dma_addr_t addr)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 */
dpaa2_fd_get_frc(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_frc(struct dpaa2_fd * fd,u32 frc)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 */
dpaa2_fd_get_ctrl(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_ctrl(struct dpaa2_fd * fd,u32 ctrl)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 */
dpaa2_fd_get_flc(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_flc(struct dpaa2_fd * fd,dma_addr_t flc_addr)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
dpaa2_fd_short_len(const struct dpaa2_fd * fd)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 */
dpaa2_fd_get_len(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_len(struct dpaa2_fd * fd,u32 len)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 */
dpaa2_fd_get_offset(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_offset(struct dpaa2_fd * fd,uint16_t offset)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 */
dpaa2_fd_get_format(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_format(struct dpaa2_fd * fd,enum dpaa2_fd_format format)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 */
dpaa2_fd_get_bpid(const struct dpaa2_fd * fd)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 */
dpaa2_fd_set_bpid(struct dpaa2_fd * fd,uint16_t bpid)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 */
dpaa2_sg_get_addr(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_set_addr(struct dpaa2_sg_entry * sg,dma_addr_t addr)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
dpaa2_sg_short_len(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_get_len(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_set_len(struct dpaa2_sg_entry * sg,u32 len)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 */
dpaa2_sg_get_offset(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_set_offset(struct dpaa2_sg_entry * sg,u16 offset)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
dpaa2_sg_get_format(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_set_format(struct dpaa2_sg_entry * sg,enum dpaa2_sg_format format)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 */
dpaa2_sg_get_bpid(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_set_bpid(struct dpaa2_sg_entry * sg,u16 bpid)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 */
dpaa2_sg_is_final(const struct dpaa2_sg_entry * sg)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 */
dpaa2_sg_set_final(struct dpaa2_sg_entry * sg,bool final)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 */
dpaa2_fl_get_addr(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_addr(struct dpaa2_fl_entry * fle,dma_addr_t addr)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 */
dpaa2_fl_get_frc(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_frc(struct dpaa2_fl_entry * fle,u32 frc)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 */
dpaa2_fl_get_ctrl(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_ctrl(struct dpaa2_fl_entry * fle,u32 ctrl)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 */
dpaa2_fl_get_flc(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_flc(struct dpaa2_fl_entry * fle,dma_addr_t flc_addr)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
dpaa2_fl_short_len(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_get_len(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_len(struct dpaa2_fl_entry * fle,u32 len)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 */
dpaa2_fl_get_offset(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_offset(struct dpaa2_fl_entry * fle,u16 offset)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 */
dpaa2_fl_get_format(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_format(struct dpaa2_fl_entry * fle,enum dpaa2_fl_format format)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 */
dpaa2_fl_get_bpid(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_bpid(struct dpaa2_fl_entry * fle,u16 bpid)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 */
dpaa2_fl_is_final(const struct dpaa2_fl_entry * fle)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 */
dpaa2_fl_set_final(struct dpaa2_fl_entry * fle,bool final)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 */
681