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 */ 38struct 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 91enum 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 */ 103static 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 */ 113static 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 */ 124static 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 */ 134static 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 */ 145static 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 */ 155static 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 */ 166static 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 */ 176static 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 181static 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 */ 193static 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 */ 206static 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 */ 217static 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 */ 227static 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 */ 239static 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 */ 251static 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 */ 265static 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 */ 275static 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 */ 288struct dpaa2_sg_entry { 289 __le64 addr; 290 __le32 len; 291 __le16 bpid; 292 __le16 format_offset; 293}; 294 295enum 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 */ 309static 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 */ 319static 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 324static 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 */ 336static 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 */ 349static 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 */ 360static 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 */ 370static 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 */ 383static 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 */ 395static 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 */ 408static 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 */ 418static 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 */ 430static 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 */ 440static 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 */ 457struct 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 467enum 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 */ 479static 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 */ 489static 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 */ 501static 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 */ 511static 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 */ 522static 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 */ 532static 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 */ 543static 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 */ 553static 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 559static 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 */ 571static 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 */ 584static 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 */ 595static 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 */ 605static 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 */ 617static 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 */ 628static 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 */ 641static 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 */ 651static 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 */ 663static 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 */ 673static 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