1/* SPDX-License-Identifier: GPL-2.0 */ 2#ifndef _LINUX_SCATTERLIST_H 3#define _LINUX_SCATTERLIST_H 4 5#include <linux/string.h> 6#include <linux/types.h> 7#include <linux/bug.h> 8#include <linux/mm.h> 9#include <asm/io.h> 10 11struct scatterlist { 12 unsigned long page_link; 13 unsigned int offset; 14 unsigned int length; 15 dma_addr_t dma_address; 16#ifdef CONFIG_NEED_SG_DMA_LENGTH 17 unsigned int dma_length; 18#endif 19#ifdef CONFIG_NEED_SG_DMA_FLAGS 20 unsigned int dma_flags; 21#endif 22}; 23 24/* 25 * These macros should be used after a dma_map_sg call has been done 26 * to get bus addresses of each of the SG entries and their lengths. 27 * You should only work with the number of sg entries dma_map_sg 28 * returns, or alternatively stop on the first sg_dma_len(sg) which 29 * is 0. 30 */ 31#define sg_dma_address(sg) ((sg)->dma_address) 32 33#ifdef CONFIG_NEED_SG_DMA_LENGTH 34#define sg_dma_len(sg) ((sg)->dma_length) 35#else 36#define sg_dma_len(sg) ((sg)->length) 37#endif 38 39struct sg_table { 40 struct scatterlist *sgl; /* the list */ 41 unsigned int nents; /* number of mapped entries */ 42 unsigned int orig_nents; /* original size of list */ 43}; 44 45struct sg_append_table { 46 struct sg_table sgt; /* The scatter list table */ 47 struct scatterlist *prv; /* last populated sge in the table */ 48 unsigned int total_nents; /* Total entries in the table */ 49}; 50 51/* 52 * Notes on SG table design. 53 * 54 * We use the unsigned long page_link field in the scatterlist struct to place 55 * the page pointer AND encode information about the sg table as well. The two 56 * lower bits are reserved for this information. 57 * 58 * If bit 0 is set, then the page_link contains a pointer to the next sg 59 * table list. Otherwise the next entry is at sg + 1. 60 * 61 * If bit 1 is set, then this sg entry is the last element in a list. 62 * 63 * See sg_next(). 64 * 65 */ 66 67#define SG_CHAIN 0x01UL 68#define SG_END 0x02UL 69 70/* 71 * We overload the LSB of the page pointer to indicate whether it's 72 * a valid sg entry, or whether it points to the start of a new scatterlist. 73 * Those low bits are there for everyone! (thanks mason :-) 74 */ 75#define SG_PAGE_LINK_MASK (SG_CHAIN | SG_END) 76 77static inline unsigned int __sg_flags(struct scatterlist *sg) 78{ 79 return sg->page_link & SG_PAGE_LINK_MASK; 80} 81 82static inline struct scatterlist *sg_chain_ptr(struct scatterlist *sg) 83{ 84 return (struct scatterlist *)(sg->page_link & ~SG_PAGE_LINK_MASK); 85} 86 87static inline bool sg_is_chain(struct scatterlist *sg) 88{ 89 return __sg_flags(sg) & SG_CHAIN; 90} 91 92static inline bool sg_is_last(struct scatterlist *sg) 93{ 94 return __sg_flags(sg) & SG_END; 95} 96 97/** 98 * sg_assign_page - Assign a given page to an SG entry 99 * @sg: SG entry 100 * @page: The page 101 * 102 * Description: 103 * Assign page to sg entry. Also see sg_set_page(), the most commonly used 104 * variant. 105 * 106 **/ 107static inline void sg_assign_page(struct scatterlist *sg, struct page *page) 108{ 109 unsigned long page_link = sg->page_link & (SG_CHAIN | SG_END); 110 111 /* 112 * In order for the low bit stealing approach to work, pages 113 * must be aligned at a 32-bit boundary as a minimum. 114 */ 115 BUG_ON((unsigned long)page & SG_PAGE_LINK_MASK); 116#ifdef CONFIG_DEBUG_SG 117 BUG_ON(sg_is_chain(sg)); 118#endif 119 sg->page_link = page_link | (unsigned long) page; 120} 121 122/** 123 * sg_set_page - Set sg entry to point at given page 124 * @sg: SG entry 125 * @page: The page 126 * @len: Length of data 127 * @offset: Offset into page 128 * 129 * Description: 130 * Use this function to set an sg entry pointing at a page, never assign 131 * the page directly. We encode sg table information in the lower bits 132 * of the page pointer. See sg_page() for looking up the page belonging 133 * to an sg entry. 134 * 135 **/ 136static inline void sg_set_page(struct scatterlist *sg, struct page *page, 137 unsigned int len, unsigned int offset) 138{ 139 sg_assign_page(sg, page); 140 sg->offset = offset; 141 sg->length = len; 142} 143 144/** 145 * sg_set_folio - Set sg entry to point at given folio 146 * @sg: SG entry 147 * @folio: The folio 148 * @len: Length of data 149 * @offset: Offset into folio 150 * 151 * Description: 152 * Use this function to set an sg entry pointing at a folio, never assign 153 * the folio directly. We encode sg table information in the lower bits 154 * of the folio pointer. See sg_page() for looking up the page belonging 155 * to an sg entry. 156 * 157 **/ 158static inline void sg_set_folio(struct scatterlist *sg, struct folio *folio, 159 size_t len, size_t offset) 160{ 161 WARN_ON_ONCE(len > UINT_MAX); 162 WARN_ON_ONCE(offset > UINT_MAX); 163 sg_assign_page(sg, &folio->page); 164 sg->offset = offset; 165 sg->length = len; 166} 167 168static inline struct page *sg_page(struct scatterlist *sg) 169{ 170#ifdef CONFIG_DEBUG_SG 171 BUG_ON(sg_is_chain(sg)); 172#endif 173 return (struct page *)((sg)->page_link & ~SG_PAGE_LINK_MASK); 174} 175 176/** 177 * sg_set_buf - Set sg entry to point at given data 178 * @sg: SG entry 179 * @buf: Data 180 * @buflen: Data length 181 * 182 **/ 183static inline void sg_set_buf(struct scatterlist *sg, const void *buf, 184 unsigned int buflen) 185{ 186#ifdef CONFIG_DEBUG_SG 187 BUG_ON(!virt_addr_valid(buf)); 188#endif 189 sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf)); 190} 191 192/* 193 * Loop over each sg element, following the pointer to a new list if necessary 194 */ 195#define for_each_sg(sglist, sg, nr, __i) \ 196 for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg)) 197 198/* 199 * Loop over each sg element in the given sg_table object. 200 */ 201#define for_each_sgtable_sg(sgt, sg, i) \ 202 for_each_sg((sgt)->sgl, sg, (sgt)->orig_nents, i) 203 204/* 205 * Loop over each sg element in the given *DMA mapped* sg_table object. 206 * Please use sg_dma_address(sg) and sg_dma_len(sg) to extract DMA addresses 207 * of the each element. 208 */ 209#define for_each_sgtable_dma_sg(sgt, sg, i) \ 210 for_each_sg((sgt)->sgl, sg, (sgt)->nents, i) 211 212static inline void __sg_chain(struct scatterlist *chain_sg, 213 struct scatterlist *sgl) 214{ 215 /* 216 * offset and length are unused for chain entry. Clear them. 217 */ 218 chain_sg->offset = 0; 219 chain_sg->length = 0; 220 221 /* 222 * Set lowest bit to indicate a link pointer, and make sure to clear 223 * the termination bit if it happens to be set. 224 */ 225 chain_sg->page_link = ((unsigned long) sgl | SG_CHAIN) & ~SG_END; 226} 227 228/** 229 * sg_chain - Chain two sglists together 230 * @prv: First scatterlist 231 * @prv_nents: Number of entries in prv 232 * @sgl: Second scatterlist 233 * 234 * Description: 235 * Links @prv@ and @sgl@ together, to form a longer scatterlist. 236 * 237 **/ 238static inline void sg_chain(struct scatterlist *prv, unsigned int prv_nents, 239 struct scatterlist *sgl) 240{ 241 __sg_chain(&prv[prv_nents - 1], sgl); 242} 243 244/** 245 * sg_mark_end - Mark the end of the scatterlist 246 * @sg: SG entryScatterlist 247 * 248 * Description: 249 * Marks the passed in sg entry as the termination point for the sg 250 * table. A call to sg_next() on this entry will return NULL. 251 * 252 **/ 253static inline void sg_mark_end(struct scatterlist *sg) 254{ 255 /* 256 * Set termination bit, clear potential chain bit 257 */ 258 sg->page_link |= SG_END; 259 sg->page_link &= ~SG_CHAIN; 260} 261 262/** 263 * sg_unmark_end - Undo setting the end of the scatterlist 264 * @sg: SG entryScatterlist 265 * 266 * Description: 267 * Removes the termination marker from the given entry of the scatterlist. 268 * 269 **/ 270static inline void sg_unmark_end(struct scatterlist *sg) 271{ 272 sg->page_link &= ~SG_END; 273} 274 275/* 276 * One 64-bit architectures there is a 4-byte padding in struct scatterlist 277 * (assuming also CONFIG_NEED_SG_DMA_LENGTH is set). Use this padding for DMA 278 * flags bits to indicate when a specific dma address is a bus address or the 279 * buffer may have been bounced via SWIOTLB. 280 */ 281#ifdef CONFIG_NEED_SG_DMA_FLAGS 282 283#define SG_DMA_BUS_ADDRESS (1 << 0) 284#define SG_DMA_SWIOTLB (1 << 1) 285 286/** 287 * sg_dma_is_bus_address - Return whether a given segment was marked 288 * as a bus address 289 * @sg: SG entry 290 * 291 * Description: 292 * Returns true if sg_dma_mark_bus_address() has been called on 293 * this segment. 294 **/ 295static inline bool sg_dma_is_bus_address(struct scatterlist *sg) 296{ 297 return sg->dma_flags & SG_DMA_BUS_ADDRESS; 298} 299 300/** 301 * sg_dma_mark_bus_address - Mark the scatterlist entry as a bus address 302 * @sg: SG entry 303 * 304 * Description: 305 * Marks the passed in sg entry to indicate that the dma_address is 306 * a bus address and doesn't need to be unmapped. This should only be 307 * used by dma_map_sg() implementations to mark bus addresses 308 * so they can be properly cleaned up in dma_unmap_sg(). 309 **/ 310static inline void sg_dma_mark_bus_address(struct scatterlist *sg) 311{ 312 sg->dma_flags |= SG_DMA_BUS_ADDRESS; 313} 314 315/** 316 * sg_unmark_bus_address - Unmark the scatterlist entry as a bus address 317 * @sg: SG entry 318 * 319 * Description: 320 * Clears the bus address mark. 321 **/ 322static inline void sg_dma_unmark_bus_address(struct scatterlist *sg) 323{ 324 sg->dma_flags &= ~SG_DMA_BUS_ADDRESS; 325} 326 327/** 328 * sg_dma_is_swiotlb - Return whether the scatterlist was marked for SWIOTLB 329 * bouncing 330 * @sg: SG entry 331 * 332 * Description: 333 * Returns true if the scatterlist was marked for SWIOTLB bouncing. Not all 334 * elements may have been bounced, so the caller would have to check 335 * individual SG entries with is_swiotlb_buffer(). 336 */ 337static inline bool sg_dma_is_swiotlb(struct scatterlist *sg) 338{ 339 return sg->dma_flags & SG_DMA_SWIOTLB; 340} 341 342/** 343 * sg_dma_mark_swiotlb - Mark the scatterlist for SWIOTLB bouncing 344 * @sg: SG entry 345 * 346 * Description: 347 * Marks a a scatterlist for SWIOTLB bounce. Not all SG entries may be 348 * bounced. 349 */ 350static inline void sg_dma_mark_swiotlb(struct scatterlist *sg) 351{ 352 sg->dma_flags |= SG_DMA_SWIOTLB; 353} 354 355#else 356 357static inline bool sg_dma_is_bus_address(struct scatterlist *sg) 358{ 359 return false; 360} 361static inline void sg_dma_mark_bus_address(struct scatterlist *sg) 362{ 363} 364static inline void sg_dma_unmark_bus_address(struct scatterlist *sg) 365{ 366} 367static inline bool sg_dma_is_swiotlb(struct scatterlist *sg) 368{ 369 return false; 370} 371static inline void sg_dma_mark_swiotlb(struct scatterlist *sg) 372{ 373} 374 375#endif /* CONFIG_NEED_SG_DMA_FLAGS */ 376 377/** 378 * sg_phys - Return physical address of an sg entry 379 * @sg: SG entry 380 * 381 * Description: 382 * This calls page_to_phys() on the page in this sg entry, and adds the 383 * sg offset. The caller must know that it is legal to call page_to_phys() 384 * on the sg page. 385 * 386 **/ 387static inline dma_addr_t sg_phys(struct scatterlist *sg) 388{ 389 return page_to_phys(sg_page(sg)) + sg->offset; 390} 391 392/** 393 * sg_virt - Return virtual address of an sg entry 394 * @sg: SG entry 395 * 396 * Description: 397 * This calls page_address() on the page in this sg entry, and adds the 398 * sg offset. The caller must know that the sg page has a valid virtual 399 * mapping. 400 * 401 **/ 402static inline void *sg_virt(struct scatterlist *sg) 403{ 404 return page_address(sg_page(sg)) + sg->offset; 405} 406 407/** 408 * sg_init_marker - Initialize markers in sg table 409 * @sgl: The SG table 410 * @nents: Number of entries in table 411 * 412 **/ 413static inline void sg_init_marker(struct scatterlist *sgl, 414 unsigned int nents) 415{ 416 sg_mark_end(&sgl[nents - 1]); 417} 418 419int sg_nents(struct scatterlist *sg); 420int sg_nents_for_len(struct scatterlist *sg, u64 len); 421struct scatterlist *sg_next(struct scatterlist *); 422struct scatterlist *sg_last(struct scatterlist *s, unsigned int); 423void sg_init_table(struct scatterlist *, unsigned int); 424void sg_init_one(struct scatterlist *, const void *, unsigned int); 425int sg_split(struct scatterlist *in, const int in_mapped_nents, 426 const off_t skip, const int nb_splits, 427 const size_t *split_sizes, 428 struct scatterlist **out, int *out_mapped_nents, 429 gfp_t gfp_mask); 430 431typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t); 432typedef void (sg_free_fn)(struct scatterlist *, unsigned int); 433 434void __sg_free_table(struct sg_table *, unsigned int, unsigned int, 435 sg_free_fn *, unsigned int); 436void sg_free_table(struct sg_table *); 437void sg_free_append_table(struct sg_append_table *sgt); 438int __sg_alloc_table(struct sg_table *, unsigned int, unsigned int, 439 struct scatterlist *, unsigned int, gfp_t, sg_alloc_fn *); 440int sg_alloc_table(struct sg_table *, unsigned int, gfp_t); 441int sg_alloc_append_table_from_pages(struct sg_append_table *sgt, 442 struct page **pages, unsigned int n_pages, 443 unsigned int offset, unsigned long size, 444 unsigned int max_segment, 445 unsigned int left_pages, gfp_t gfp_mask); 446int sg_alloc_table_from_pages_segment(struct sg_table *sgt, struct page **pages, 447 unsigned int n_pages, unsigned int offset, 448 unsigned long size, 449 unsigned int max_segment, gfp_t gfp_mask); 450 451/** 452 * sg_alloc_table_from_pages - Allocate and initialize an sg table from 453 * an array of pages 454 * @sgt: The sg table header to use 455 * @pages: Pointer to an array of page pointers 456 * @n_pages: Number of pages in the pages array 457 * @offset: Offset from start of the first page to the start of a buffer 458 * @size: Number of valid bytes in the buffer (after offset) 459 * @gfp_mask: GFP allocation mask 460 * 461 * Description: 462 * Allocate and initialize an sg table from a list of pages. Contiguous 463 * ranges of the pages are squashed into a single scatterlist node. A user 464 * may provide an offset at a start and a size of valid data in a buffer 465 * specified by the page array. The returned sg table is released by 466 * sg_free_table. 467 * 468 * Returns: 469 * 0 on success, negative error on failure 470 */ 471static inline int sg_alloc_table_from_pages(struct sg_table *sgt, 472 struct page **pages, 473 unsigned int n_pages, 474 unsigned int offset, 475 unsigned long size, gfp_t gfp_mask) 476{ 477 return sg_alloc_table_from_pages_segment(sgt, pages, n_pages, offset, 478 size, UINT_MAX, gfp_mask); 479} 480 481#ifdef CONFIG_SGL_ALLOC 482struct scatterlist *sgl_alloc_order(unsigned long long length, 483 unsigned int order, bool chainable, 484 gfp_t gfp, unsigned int *nent_p); 485struct scatterlist *sgl_alloc(unsigned long long length, gfp_t gfp, 486 unsigned int *nent_p); 487void sgl_free_n_order(struct scatterlist *sgl, int nents, int order); 488void sgl_free_order(struct scatterlist *sgl, int order); 489void sgl_free(struct scatterlist *sgl); 490#endif /* CONFIG_SGL_ALLOC */ 491 492size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf, 493 size_t buflen, off_t skip, bool to_buffer); 494 495size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents, 496 const void *buf, size_t buflen); 497size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents, 498 void *buf, size_t buflen); 499 500size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents, 501 const void *buf, size_t buflen, off_t skip); 502size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents, 503 void *buf, size_t buflen, off_t skip); 504size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents, 505 size_t buflen, off_t skip); 506 507/* 508 * Maximum number of entries that will be allocated in one piece, if 509 * a list larger than this is required then chaining will be utilized. 510 */ 511#define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist)) 512 513/* 514 * The maximum number of SG segments that we will put inside a 515 * scatterlist (unless chaining is used). Should ideally fit inside a 516 * single page, to avoid a higher order allocation. We could define this 517 * to SG_MAX_SINGLE_ALLOC to pack correctly at the highest order. The 518 * minimum value is 32 519 */ 520#define SG_CHUNK_SIZE 128 521 522/* 523 * Like SG_CHUNK_SIZE, but for archs that have sg chaining. This limit 524 * is totally arbitrary, a setting of 2048 will get you at least 8mb ios. 525 */ 526#ifdef CONFIG_ARCH_NO_SG_CHAIN 527#define SG_MAX_SEGMENTS SG_CHUNK_SIZE 528#else 529#define SG_MAX_SEGMENTS 2048 530#endif 531 532#ifdef CONFIG_SG_POOL 533void sg_free_table_chained(struct sg_table *table, 534 unsigned nents_first_chunk); 535int sg_alloc_table_chained(struct sg_table *table, int nents, 536 struct scatterlist *first_chunk, 537 unsigned nents_first_chunk); 538#endif 539 540/* 541 * sg page iterator 542 * 543 * Iterates over sg entries page-by-page. On each successful iteration, you 544 * can call sg_page_iter_page(@piter) to get the current page. 545 * @piter->sg will point to the sg holding this page and @piter->sg_pgoffset to 546 * the page's page offset within the sg. The iteration will stop either when a 547 * maximum number of sg entries was reached or a terminating sg 548 * (sg_last(sg) == true) was reached. 549 */ 550struct sg_page_iter { 551 struct scatterlist *sg; /* sg holding the page */ 552 unsigned int sg_pgoffset; /* page offset within the sg */ 553 554 /* these are internal states, keep away */ 555 unsigned int __nents; /* remaining sg entries */ 556 int __pg_advance; /* nr pages to advance at the 557 * next step */ 558}; 559 560/* 561 * sg page iterator for DMA addresses 562 * 563 * This is the same as sg_page_iter however you can call 564 * sg_page_iter_dma_address(@dma_iter) to get the page's DMA 565 * address. sg_page_iter_page() cannot be called on this iterator. 566 */ 567struct sg_dma_page_iter { 568 struct sg_page_iter base; 569}; 570 571bool __sg_page_iter_next(struct sg_page_iter *piter); 572bool __sg_page_iter_dma_next(struct sg_dma_page_iter *dma_iter); 573void __sg_page_iter_start(struct sg_page_iter *piter, 574 struct scatterlist *sglist, unsigned int nents, 575 unsigned long pgoffset); 576/** 577 * sg_page_iter_page - get the current page held by the page iterator 578 * @piter: page iterator holding the page 579 */ 580static inline struct page *sg_page_iter_page(struct sg_page_iter *piter) 581{ 582 return nth_page(sg_page(piter->sg), piter->sg_pgoffset); 583} 584 585/** 586 * sg_page_iter_dma_address - get the dma address of the current page held by 587 * the page iterator. 588 * @dma_iter: page iterator holding the page 589 */ 590static inline dma_addr_t 591sg_page_iter_dma_address(struct sg_dma_page_iter *dma_iter) 592{ 593 return sg_dma_address(dma_iter->base.sg) + 594 (dma_iter->base.sg_pgoffset << PAGE_SHIFT); 595} 596 597/** 598 * for_each_sg_page - iterate over the pages of the given sg list 599 * @sglist: sglist to iterate over 600 * @piter: page iterator to hold current page, sg, sg_pgoffset 601 * @nents: maximum number of sg entries to iterate over 602 * @pgoffset: starting page offset (in pages) 603 * 604 * Callers may use sg_page_iter_page() to get each page pointer. 605 * In each loop it operates on PAGE_SIZE unit. 606 */ 607#define for_each_sg_page(sglist, piter, nents, pgoffset) \ 608 for (__sg_page_iter_start((piter), (sglist), (nents), (pgoffset)); \ 609 __sg_page_iter_next(piter);) 610 611/** 612 * for_each_sg_dma_page - iterate over the pages of the given sg list 613 * @sglist: sglist to iterate over 614 * @dma_iter: DMA page iterator to hold current page 615 * @dma_nents: maximum number of sg entries to iterate over, this is the value 616 * returned from dma_map_sg 617 * @pgoffset: starting page offset (in pages) 618 * 619 * Callers may use sg_page_iter_dma_address() to get each page's DMA address. 620 * In each loop it operates on PAGE_SIZE unit. 621 */ 622#define for_each_sg_dma_page(sglist, dma_iter, dma_nents, pgoffset) \ 623 for (__sg_page_iter_start(&(dma_iter)->base, sglist, dma_nents, \ 624 pgoffset); \ 625 __sg_page_iter_dma_next(dma_iter);) 626 627/** 628 * for_each_sgtable_page - iterate over all pages in the sg_table object 629 * @sgt: sg_table object to iterate over 630 * @piter: page iterator to hold current page 631 * @pgoffset: starting page offset (in pages) 632 * 633 * Iterates over the all memory pages in the buffer described by 634 * a scatterlist stored in the given sg_table object. 635 * See also for_each_sg_page(). In each loop it operates on PAGE_SIZE unit. 636 */ 637#define for_each_sgtable_page(sgt, piter, pgoffset) \ 638 for_each_sg_page((sgt)->sgl, piter, (sgt)->orig_nents, pgoffset) 639 640/** 641 * for_each_sgtable_dma_page - iterate over the DMA mapped sg_table object 642 * @sgt: sg_table object to iterate over 643 * @dma_iter: DMA page iterator to hold current page 644 * @pgoffset: starting page offset (in pages) 645 * 646 * Iterates over the all DMA mapped pages in the buffer described by 647 * a scatterlist stored in the given sg_table object. 648 * See also for_each_sg_dma_page(). In each loop it operates on PAGE_SIZE 649 * unit. 650 */ 651#define for_each_sgtable_dma_page(sgt, dma_iter, pgoffset) \ 652 for_each_sg_dma_page((sgt)->sgl, dma_iter, (sgt)->nents, pgoffset) 653 654 655/* 656 * Mapping sg iterator 657 * 658 * Iterates over sg entries mapping page-by-page. On each successful 659 * iteration, @miter->page points to the mapped page and 660 * @miter->length bytes of data can be accessed at @miter->addr. As 661 * long as an iteration is enclosed between start and stop, the user 662 * is free to choose control structure and when to stop. 663 * 664 * @miter->consumed is set to @miter->length on each iteration. It 665 * can be adjusted if the user can't consume all the bytes in one go. 666 * Also, a stopped iteration can be resumed by calling next on it. 667 * This is useful when iteration needs to release all resources and 668 * continue later (e.g. at the next interrupt). 669 */ 670 671#define SG_MITER_ATOMIC (1 << 0) /* use kmap_atomic */ 672#define SG_MITER_TO_SG (1 << 1) /* flush back to phys on unmap */ 673#define SG_MITER_FROM_SG (1 << 2) /* nop */ 674 675struct sg_mapping_iter { 676 /* the following three fields can be accessed directly */ 677 struct page *page; /* currently mapped page */ 678 void *addr; /* pointer to the mapped area */ 679 size_t length; /* length of the mapped area */ 680 size_t consumed; /* number of consumed bytes */ 681 struct sg_page_iter piter; /* page iterator */ 682 683 /* these are internal states, keep away */ 684 unsigned int __offset; /* offset within page */ 685 unsigned int __remaining; /* remaining bytes on page */ 686 unsigned int __flags; 687}; 688 689void sg_miter_start(struct sg_mapping_iter *miter, struct scatterlist *sgl, 690 unsigned int nents, unsigned int flags); 691bool sg_miter_skip(struct sg_mapping_iter *miter, off_t offset); 692bool sg_miter_next(struct sg_mapping_iter *miter); 693void sg_miter_stop(struct sg_mapping_iter *miter); 694 695#endif /* _LINUX_SCATTERLIST_H */ 696