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 */