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
  70 /* Error bits in FD CTRL */
  71 #define FD_CTRL_ERR_MASK        0x000000FF
  72 #define FD_CTRL_UFD             0x00000004
  73 #define FD_CTRL_SBE             0x00000008
  74 #define FD_CTRL_FLC             0x00000010
  75 #define FD_CTRL_FSE             0x00000020
  76 #define FD_CTRL_FAERR           0x00000040
  77
  78 /* Annotation bits in FD CTRL */
  79 #define FD_CTRL_PTA             0x00800000
  80 #define FD_CTRL_PTV1            0x00400000
  81
  82 enum dpaa2_fd_format {
  83         dpaa2_fd_single = 0,
  84         dpaa2_fd_list,
  85         dpaa2_fd_sg
  86 };
  87
  88 /**
  89  * dpaa2_fd_get_addr() - get the addr field of frame descriptor
  90  * @fd: the given frame descriptor
  91  *
  92  * Return the address in the frame descriptor.
  93  */
  94 static inline dma_addr_t dpaa2_fd_get_addr(const struct dpaa2_fd *fd)
  95 {
  96         return (dma_addr_t)le64_to_cpu(fd->simple.addr);
  97 }
  98
  99 /**
 100  * dpaa2_fd_set_addr() - Set the addr field of frame descriptor
 101  * @fd: the given frame descriptor
 102  * @addr: the address needs to be set in frame descriptor
 103  */
 104 static inline void dpaa2_fd_set_addr(struct dpaa2_fd *fd, dma_addr_t addr)
 105 {
 106         fd->simple.addr = cpu_to_le64(addr);
 107 }
 108
 109 /**
 110  * dpaa2_fd_get_frc() - Get the frame context in the frame descriptor
 111  * @fd: the given frame descriptor
 112  *
 113  * Return the frame context field in the frame descriptor.
 114  */
 115 static inline u32 dpaa2_fd_get_frc(const struct dpaa2_fd *fd)
 116 {
 117         return le32_to_cpu(fd->simple.frc);
 118 }
 119
 120 /**
 121  * dpaa2_fd_set_frc() - Set the frame context in the frame descriptor
 122  * @fd: the given frame descriptor
 123  * @frc: the frame context needs to be set in frame descriptor
 124  */
 125 static inline void dpaa2_fd_set_frc(struct dpaa2_fd *fd, u32 frc)
 126 {
 127         fd->simple.frc = cpu_to_le32(frc);
 128 }
 129
 130 /**
 131  * dpaa2_fd_get_ctrl() - Get the control bits in the frame descriptor
 132  * @fd: the given frame descriptor
 133  *
 134  * Return the control bits field in the frame descriptor.
 135  */
 136 static inline u32 dpaa2_fd_get_ctrl(const struct dpaa2_fd *fd)
 137 {
 138         return le32_to_cpu(fd->simple.ctrl);
 139 }
 140
 141 /**
 142  * dpaa2_fd_set_ctrl() - Set the control bits in the frame descriptor
 143  * @fd: the given frame descriptor
 144  * @ctrl: the control bits to be set in the frame descriptor
 145  */
 146 static inline void dpaa2_fd_set_ctrl(struct dpaa2_fd *fd, u32 ctrl)
 147 {
 148         fd->simple.ctrl = cpu_to_le32(ctrl);
 149 }
 150
 151 /**
 152  * dpaa2_fd_get_flc() - Get the flow context in the frame descriptor
 153  * @fd: the given frame descriptor
 154  *
 155  * Return the flow context in the frame descriptor.
 156  */
 157 static inline dma_addr_t dpaa2_fd_get_flc(const struct dpaa2_fd *fd)
 158 {
 159         return (dma_addr_t)le64_to_cpu(fd->simple.flc);
 160 }
 161
 162 /**
 163  * dpaa2_fd_set_flc() - Set the flow context field of frame descriptor
 164  * @fd: the given frame descriptor
 165  * @flc_addr: the flow context needs to be set in frame descriptor
 166  */
 167 static inline void dpaa2_fd_set_flc(struct dpaa2_fd *fd,  dma_addr_t flc_addr)
 168 {
 169         fd->simple.flc = cpu_to_le64(flc_addr);
 170 }
 171
 172 static inline bool dpaa2_fd_short_len(const struct dpaa2_fd *fd)
 173 {
 174         return !!((le16_to_cpu(fd->simple.format_offset) >>
 175                   FD_SHORT_LEN_FLAG_SHIFT) & FD_SHORT_LEN_FLAG_MASK);
 176 }
 177
 178 /**
 179  * dpaa2_fd_get_len() - Get the length in the frame descriptor
 180  * @fd: the given frame descriptor
 181  *
 182  * Return the length field in the frame descriptor.
 183  */
 184 static inline u32 dpaa2_fd_get_len(const struct dpaa2_fd *fd)
 185 {
 186         if (dpaa2_fd_short_len(fd))
 187                 return le32_to_cpu(fd->simple.len) & FD_SHORT_LEN_MASK;
 188
 189         return le32_to_cpu(fd->simple.len);
 190 }
 191
 192 /**
 193  * dpaa2_fd_set_len() - Set the length field of frame descriptor
 194  * @fd: the given frame descriptor
 195  * @len: the length needs to be set in frame descriptor
 196  */
 197 static inline void dpaa2_fd_set_len(struct dpaa2_fd *fd, u32 len)
 198 {
 199         fd->simple.len = cpu_to_le32(len);
 200 }
 201
 202 /**
 203  * dpaa2_fd_get_offset() - Get the offset field in the frame descriptor
 204  * @fd: the given frame descriptor
 205  *
 206  * Return the offset.
 207  */
 208 static inline uint16_t dpaa2_fd_get_offset(const struct dpaa2_fd *fd)
 209 {
 210         return le16_to_cpu(fd->simple.format_offset) & FD_OFFSET_MASK;
 211 }
 212
 213 /**
 214  * dpaa2_fd_set_offset() - Set the offset field of frame descriptor
 215  * @fd: the given frame descriptor
 216  * @offset: the offset needs to be set in frame descriptor
 217  */
 218 static inline void dpaa2_fd_set_offset(struct dpaa2_fd *fd, uint16_t offset)
 219 {
 220         fd->simple.format_offset &= cpu_to_le16(~FD_OFFSET_MASK);
 221         fd->simple.format_offset |= cpu_to_le16(offset);
 222 }
 223
 224 /**
 225  * dpaa2_fd_get_format() - Get the format field in the frame descriptor
 226  * @fd: the given frame descriptor
 227  *
 228  * Return the format.
 229  */
 230 static inline enum dpaa2_fd_format dpaa2_fd_get_format(
 231                                                 const struct dpaa2_fd *fd)
 232 {
 233         return (enum dpaa2_fd_format)((le16_to_cpu(fd->simple.format_offset)
 234                                       >> FD_FORMAT_SHIFT) & FD_FORMAT_MASK);
 235 }
 236
 237 /**
 238  * dpaa2_fd_set_format() - Set the format field of frame descriptor
 239  * @fd: the given frame descriptor
 240  * @format: the format needs to be set in frame descriptor
 241  */
 242 static inline void dpaa2_fd_set_format(struct dpaa2_fd *fd,
 243                                        enum dpaa2_fd_format format)
 244 {
 245         fd->simple.format_offset &=
 246                 cpu_to_le16(~(FD_FORMAT_MASK << FD_FORMAT_SHIFT));
 247         fd->simple.format_offset |= cpu_to_le16(format << FD_FORMAT_SHIFT);
 248 }
 249
 250 /**
 251  * dpaa2_fd_get_bpid() - Get the bpid field in the frame descriptor
 252  * @fd: the given frame descriptor
 253  *
 254  * Return the buffer pool id.
 255  */
 256 static inline uint16_t dpaa2_fd_get_bpid(const struct dpaa2_fd *fd)
 257 {
 258         return le16_to_cpu(fd->simple.bpid) & FD_BPID_MASK;
 259 }
 260
 261 /**
 262  * dpaa2_fd_set_bpid() - Set the bpid field of frame descriptor
 263  * @fd: the given frame descriptor
 264  * @bpid: buffer pool id to be set
 265  */
 266 static inline void dpaa2_fd_set_bpid(struct dpaa2_fd *fd, uint16_t bpid)
 267 {
 268         fd->simple.bpid &= cpu_to_le16(~(FD_BPID_MASK));
 269         fd->simple.bpid |= cpu_to_le16(bpid);
 270 }
 271
 272 /**
 273  * struct dpaa2_sg_entry - the scatter-gathering structure
 274  * @addr: address of the sg entry
 275  * @len: length in this sg entry
 276  * @bpid: buffer pool id
 277  * @format_offset: format and offset fields
 278  */
 279 struct dpaa2_sg_entry {
 280         __le64 addr;
 281         __le32 len;
 282         __le16 bpid;
 283         __le16 format_offset;
 284 };
 285
 286 enum dpaa2_sg_format {
 287         dpaa2_sg_single = 0,
 288         dpaa2_sg_frame_data,
 289         dpaa2_sg_sgt_ext
 290 };
 291
 292 /* Accessors for SG entry fields */
 293
 294 /**
 295  * dpaa2_sg_get_addr() - Get the address from SG entry
 296  * @sg: the given scatter-gathering object
 297  *
 298  * Return the address.
 299  */
 300 static inline dma_addr_t dpaa2_sg_get_addr(const struct dpaa2_sg_entry *sg)
 301 {
 302         return (dma_addr_t)le64_to_cpu(sg->addr);
 303 }
 304
 305 /**
 306  * dpaa2_sg_set_addr() - Set the address in SG entry
 307  * @sg: the given scatter-gathering object
 308  * @addr: the address to be set
 309  */
 310 static inline void dpaa2_sg_set_addr(struct dpaa2_sg_entry *sg, dma_addr_t addr)
 311 {
 312         sg->addr = cpu_to_le64(addr);
 313 }
 314
 315 static inline bool dpaa2_sg_short_len(const struct dpaa2_sg_entry *sg)
 316 {
 317         return !!((le16_to_cpu(sg->format_offset) >> SG_SHORT_LEN_FLAG_SHIFT)
 318                 & SG_SHORT_LEN_FLAG_MASK);
 319 }
 320
 321 /**
 322  * dpaa2_sg_get_len() - Get the length in SG entry
 323  * @sg: the given scatter-gathering object
 324  *
 325  * Return the length.
 326  */
 327 static inline u32 dpaa2_sg_get_len(const struct dpaa2_sg_entry *sg)
 328 {
 329         if (dpaa2_sg_short_len(sg))
 330                 return le32_to_cpu(sg->len) & SG_SHORT_LEN_MASK;
 331
 332         return le32_to_cpu(sg->len);
 333 }
 334
 335 /**
 336  * dpaa2_sg_set_len() - Set the length in SG entry
 337  * @sg: the given scatter-gathering object
 338  * @len: the length to be set
 339  */
 340 static inline void dpaa2_sg_set_len(struct dpaa2_sg_entry *sg, u32 len)
 341 {
 342         sg->len = cpu_to_le32(len);
 343 }
 344
 345 /**
 346  * dpaa2_sg_get_offset() - Get the offset in SG entry
 347  * @sg: the given scatter-gathering object
 348  *
 349  * Return the offset.
 350  */
 351 static inline u16 dpaa2_sg_get_offset(const struct dpaa2_sg_entry *sg)
 352 {
 353         return le16_to_cpu(sg->format_offset) & SG_OFFSET_MASK;
 354 }
 355
 356 /**
 357  * dpaa2_sg_set_offset() - Set the offset in SG entry
 358  * @sg: the given scatter-gathering object
 359  * @offset: the offset to be set
 360  */
 361 static inline void dpaa2_sg_set_offset(struct dpaa2_sg_entry *sg,
 362                                        u16 offset)
 363 {
 364         sg->format_offset &= cpu_to_le16(~SG_OFFSET_MASK);
 365         sg->format_offset |= cpu_to_le16(offset);
 366 }
 367
 368 /**
 369  * dpaa2_sg_get_format() - Get the SG format in SG entry
 370  * @sg: the given scatter-gathering object
 371  *
 372  * Return the format.
 373  */
 374 static inline enum dpaa2_sg_format
 375         dpaa2_sg_get_format(const struct dpaa2_sg_entry *sg)
 376 {
 377         return (enum dpaa2_sg_format)((le16_to_cpu(sg->format_offset)
 378                                        >> SG_FORMAT_SHIFT) & SG_FORMAT_MASK);
 379 }
 380
 381 /**
 382  * dpaa2_sg_set_format() - Set the SG format in SG entry
 383  * @sg: the given scatter-gathering object
 384  * @format: the format to be set
 385  */
 386 static inline void dpaa2_sg_set_format(struct dpaa2_sg_entry *sg,
 387                                        enum dpaa2_sg_format format)
 388 {
 389         sg->format_offset &= cpu_to_le16(~(SG_FORMAT_MASK << SG_FORMAT_SHIFT));
 390         sg->format_offset |= cpu_to_le16(format << SG_FORMAT_SHIFT);
 391 }
 392
 393 /**
 394  * dpaa2_sg_get_bpid() - Get the buffer pool id in SG entry
 395  * @sg: the given scatter-gathering object
 396  *
 397  * Return the bpid.
 398  */
 399 static inline u16 dpaa2_sg_get_bpid(const struct dpaa2_sg_entry *sg)
 400 {
 401         return le16_to_cpu(sg->bpid) & SG_BPID_MASK;
 402 }
 403
 404 /**
 405  * dpaa2_sg_set_bpid() - Set the buffer pool id in SG entry
 406  * @sg: the given scatter-gathering object
 407  * @bpid: the bpid to be set
 408  */
 409 static inline void dpaa2_sg_set_bpid(struct dpaa2_sg_entry *sg, u16 bpid)
 410 {
 411         sg->bpid &= cpu_to_le16(~(SG_BPID_MASK));
 412         sg->bpid |= cpu_to_le16(bpid);
 413 }
 414
 415 /**
 416  * dpaa2_sg_is_final() - Check final bit in SG entry
 417  * @sg: the given scatter-gathering object
 418  *
 419  * Return bool.
 420  */
 421 static inline bool dpaa2_sg_is_final(const struct dpaa2_sg_entry *sg)
 422 {
 423         return !!(le16_to_cpu(sg->format_offset) >> SG_FINAL_FLAG_SHIFT);
 424 }
 425
 426 /**
 427  * dpaa2_sg_set_final() - Set the final bit in SG entry
 428  * @sg: the given scatter-gathering object
 429  * @final: the final boolean to be set
 430  */
 431 static inline void dpaa2_sg_set_final(struct dpaa2_sg_entry *sg, bool final)
 432 {
 433         sg->format_offset &= cpu_to_le16((~(SG_FINAL_FLAG_MASK
 434                                          << SG_FINAL_FLAG_SHIFT)) & 0xFFFF);
 435         sg->format_offset |= cpu_to_le16(final << SG_FINAL_FLAG_SHIFT);
 436 }
 437
 438 #endif /* __FSL_DPAA2_FD_H */