Line data Source code
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 :
11 : struct 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 : };
20 :
21 : /*
22 : * These macros should be used after a dma_map_sg call has been done
23 : * to get bus addresses of each of the SG entries and their lengths.
24 : * You should only work with the number of sg entries dma_map_sg
25 : * returns, or alternatively stop on the first sg_dma_len(sg) which
26 : * is 0.
27 : */
28 : #define sg_dma_address(sg) ((sg)->dma_address)
29 :
30 : #ifdef CONFIG_NEED_SG_DMA_LENGTH
31 : #define sg_dma_len(sg) ((sg)->dma_length)
32 : #else
33 : #define sg_dma_len(sg) ((sg)->length)
34 : #endif
35 :
36 : struct sg_table {
37 : struct scatterlist *sgl; /* the list */
38 : unsigned int nents; /* number of mapped entries */
39 : unsigned int orig_nents; /* original size of list */
40 : };
41 :
42 : /*
43 : * Notes on SG table design.
44 : *
45 : * We use the unsigned long page_link field in the scatterlist struct to place
46 : * the page pointer AND encode information about the sg table as well. The two
47 : * lower bits are reserved for this information.
48 : *
49 : * If bit 0 is set, then the page_link contains a pointer to the next sg
50 : * table list. Otherwise the next entry is at sg + 1.
51 : *
52 : * If bit 1 is set, then this sg entry is the last element in a list.
53 : *
54 : * See sg_next().
55 : *
56 : */
57 :
58 : #define SG_CHAIN 0x01UL
59 : #define SG_END 0x02UL
60 :
61 : /*
62 : * We overload the LSB of the page pointer to indicate whether it's
63 : * a valid sg entry, or whether it points to the start of a new scatterlist.
64 : * Those low bits are there for everyone! (thanks mason :-)
65 : */
66 : #define sg_is_chain(sg) ((sg)->page_link & SG_CHAIN)
67 : #define sg_is_last(sg) ((sg)->page_link & SG_END)
68 : #define sg_chain_ptr(sg) \
69 : ((struct scatterlist *) ((sg)->page_link & ~(SG_CHAIN | SG_END)))
70 :
71 : /**
72 : * sg_assign_page - Assign a given page to an SG entry
73 : * @sg: SG entry
74 : * @page: The page
75 : *
76 : * Description:
77 : * Assign page to sg entry. Also see sg_set_page(), the most commonly used
78 : * variant.
79 : *
80 : **/
81 20158 : static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
82 : {
83 20158 : unsigned long page_link = sg->page_link & (SG_CHAIN | SG_END);
84 :
85 : /*
86 : * In order for the low bit stealing approach to work, pages
87 : * must be aligned at a 32-bit boundary as a minimum.
88 : */
89 20158 : BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
90 : #ifdef CONFIG_DEBUG_SG
91 : BUG_ON(sg_is_chain(sg));
92 : #endif
93 20158 : sg->page_link = page_link | (unsigned long) page;
94 20158 : }
95 :
96 : /**
97 : * sg_set_page - Set sg entry to point at given page
98 : * @sg: SG entry
99 : * @page: The page
100 : * @len: Length of data
101 : * @offset: Offset into page
102 : *
103 : * Description:
104 : * Use this function to set an sg entry pointing at a page, never assign
105 : * the page directly. We encode sg table information in the lower bits
106 : * of the page pointer. See sg_page() for looking up the page belonging
107 : * to an sg entry.
108 : *
109 : **/
110 20158 : static inline void sg_set_page(struct scatterlist *sg, struct page *page,
111 : unsigned int len, unsigned int offset)
112 : {
113 20158 : sg_assign_page(sg, page);
114 20158 : sg->offset = offset;
115 1334 : sg->length = len;
116 0 : }
117 :
118 19655 : static inline struct page *sg_page(struct scatterlist *sg)
119 : {
120 : #ifdef CONFIG_DEBUG_SG
121 : BUG_ON(sg_is_chain(sg));
122 : #endif
123 0 : return (struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END));
124 : }
125 :
126 : /**
127 : * sg_set_buf - Set sg entry to point at given data
128 : * @sg: SG entry
129 : * @buf: Data
130 : * @buflen: Data length
131 : *
132 : **/
133 9438 : static inline void sg_set_buf(struct scatterlist *sg, const void *buf,
134 : unsigned int buflen)
135 : {
136 : #ifdef CONFIG_DEBUG_SG
137 : BUG_ON(!virt_addr_valid(buf));
138 : #endif
139 9438 : sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
140 9438 : }
141 :
142 : /*
143 : * Loop over each sg element, following the pointer to a new list if necessary
144 : */
145 : #define for_each_sg(sglist, sg, nr, __i) \
146 : for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
147 :
148 : /*
149 : * Loop over each sg element in the given sg_table object.
150 : */
151 : #define for_each_sgtable_sg(sgt, sg, i) \
152 : for_each_sg((sgt)->sgl, sg, (sgt)->orig_nents, i)
153 :
154 : /*
155 : * Loop over each sg element in the given *DMA mapped* sg_table object.
156 : * Please use sg_dma_address(sg) and sg_dma_len(sg) to extract DMA addresses
157 : * of the each element.
158 : */
159 : #define for_each_sgtable_dma_sg(sgt, sg, i) \
160 : for_each_sg((sgt)->sgl, sg, (sgt)->nents, i)
161 :
162 0 : static inline void __sg_chain(struct scatterlist *chain_sg,
163 : struct scatterlist *sgl)
164 : {
165 : /*
166 : * offset and length are unused for chain entry. Clear them.
167 : */
168 0 : chain_sg->offset = 0;
169 0 : chain_sg->length = 0;
170 :
171 : /*
172 : * Set lowest bit to indicate a link pointer, and make sure to clear
173 : * the termination bit if it happens to be set.
174 : */
175 0 : chain_sg->page_link = ((unsigned long) sgl | SG_CHAIN) & ~SG_END;
176 : }
177 :
178 : /**
179 : * sg_chain - Chain two sglists together
180 : * @prv: First scatterlist
181 : * @prv_nents: Number of entries in prv
182 : * @sgl: Second scatterlist
183 : *
184 : * Description:
185 : * Links @prv@ and @sgl@ together, to form a longer scatterlist.
186 : *
187 : **/
188 0 : static inline void sg_chain(struct scatterlist *prv, unsigned int prv_nents,
189 : struct scatterlist *sgl)
190 : {
191 0 : __sg_chain(&prv[prv_nents - 1], sgl);
192 0 : }
193 :
194 : /**
195 : * sg_mark_end - Mark the end of the scatterlist
196 : * @sg: SG entryScatterlist
197 : *
198 : * Description:
199 : * Marks the passed in sg entry as the termination point for the sg
200 : * table. A call to sg_next() on this entry will return NULL.
201 : *
202 : **/
203 14095 : static inline void sg_mark_end(struct scatterlist *sg)
204 : {
205 : /*
206 : * Set termination bit, clear potential chain bit
207 : */
208 14095 : sg->page_link |= SG_END;
209 14095 : sg->page_link &= ~SG_CHAIN;
210 3181 : }
211 :
212 : /**
213 : * sg_unmark_end - Undo setting the end of the scatterlist
214 : * @sg: SG entryScatterlist
215 : *
216 : * Description:
217 : * Removes the termination marker from the given entry of the scatterlist.
218 : *
219 : **/
220 7538 : static inline void sg_unmark_end(struct scatterlist *sg)
221 : {
222 7538 : sg->page_link &= ~SG_END;
223 : }
224 :
225 : /**
226 : * sg_phys - Return physical address of an sg entry
227 : * @sg: SG entry
228 : *
229 : * Description:
230 : * This calls page_to_phys() on the page in this sg entry, and adds the
231 : * sg offset. The caller must know that it is legal to call page_to_phys()
232 : * on the sg page.
233 : *
234 : **/
235 19655 : static inline dma_addr_t sg_phys(struct scatterlist *sg)
236 : {
237 19655 : return page_to_phys(sg_page(sg)) + sg->offset;
238 : }
239 :
240 : /**
241 : * sg_virt - Return virtual address of an sg entry
242 : * @sg: SG entry
243 : *
244 : * Description:
245 : * This calls page_address() on the page in this sg entry, and adds the
246 : * sg offset. The caller must know that the sg page has a valid virtual
247 : * mapping.
248 : *
249 : **/
250 0 : static inline void *sg_virt(struct scatterlist *sg)
251 : {
252 0 : return page_address(sg_page(sg)) + sg->offset;
253 : }
254 :
255 : /**
256 : * sg_init_marker - Initialize markers in sg table
257 : * @sgl: The SG table
258 : * @nents: Number of entries in table
259 : *
260 : **/
261 10466 : static inline void sg_init_marker(struct scatterlist *sgl,
262 : unsigned int nents)
263 : {
264 10466 : sg_mark_end(&sgl[nents - 1]);
265 : }
266 :
267 : int sg_nents(struct scatterlist *sg);
268 : int sg_nents_for_len(struct scatterlist *sg, u64 len);
269 : struct scatterlist *sg_next(struct scatterlist *);
270 : struct scatterlist *sg_last(struct scatterlist *s, unsigned int);
271 : void sg_init_table(struct scatterlist *, unsigned int);
272 : void sg_init_one(struct scatterlist *, const void *, unsigned int);
273 : int sg_split(struct scatterlist *in, const int in_mapped_nents,
274 : const off_t skip, const int nb_splits,
275 : const size_t *split_sizes,
276 : struct scatterlist **out, int *out_mapped_nents,
277 : gfp_t gfp_mask);
278 :
279 : typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t);
280 : typedef void (sg_free_fn)(struct scatterlist *, unsigned int);
281 :
282 : void __sg_free_table(struct sg_table *, unsigned int, unsigned int,
283 : sg_free_fn *);
284 : void sg_free_table(struct sg_table *);
285 : int __sg_alloc_table(struct sg_table *, unsigned int, unsigned int,
286 : struct scatterlist *, unsigned int, gfp_t, sg_alloc_fn *);
287 : int sg_alloc_table(struct sg_table *, unsigned int, gfp_t);
288 : struct scatterlist *__sg_alloc_table_from_pages(struct sg_table *sgt,
289 : struct page **pages, unsigned int n_pages, unsigned int offset,
290 : unsigned long size, unsigned int max_segment,
291 : struct scatterlist *prv, unsigned int left_pages,
292 : gfp_t gfp_mask);
293 : int sg_alloc_table_from_pages(struct sg_table *sgt, struct page **pages,
294 : unsigned int n_pages, unsigned int offset,
295 : unsigned long size, gfp_t gfp_mask);
296 :
297 : #ifdef CONFIG_SGL_ALLOC
298 : struct scatterlist *sgl_alloc_order(unsigned long long length,
299 : unsigned int order, bool chainable,
300 : gfp_t gfp, unsigned int *nent_p);
301 : struct scatterlist *sgl_alloc(unsigned long long length, gfp_t gfp,
302 : unsigned int *nent_p);
303 : void sgl_free_n_order(struct scatterlist *sgl, int nents, int order);
304 : void sgl_free_order(struct scatterlist *sgl, int order);
305 : void sgl_free(struct scatterlist *sgl);
306 : #endif /* CONFIG_SGL_ALLOC */
307 :
308 : size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf,
309 : size_t buflen, off_t skip, bool to_buffer);
310 :
311 : size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
312 : const void *buf, size_t buflen);
313 : size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
314 : void *buf, size_t buflen);
315 :
316 : size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
317 : const void *buf, size_t buflen, off_t skip);
318 : size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
319 : void *buf, size_t buflen, off_t skip);
320 : size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents,
321 : size_t buflen, off_t skip);
322 :
323 : /*
324 : * Maximum number of entries that will be allocated in one piece, if
325 : * a list larger than this is required then chaining will be utilized.
326 : */
327 : #define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist))
328 :
329 : /*
330 : * The maximum number of SG segments that we will put inside a
331 : * scatterlist (unless chaining is used). Should ideally fit inside a
332 : * single page, to avoid a higher order allocation. We could define this
333 : * to SG_MAX_SINGLE_ALLOC to pack correctly at the highest order. The
334 : * minimum value is 32
335 : */
336 : #define SG_CHUNK_SIZE 128
337 :
338 : /*
339 : * Like SG_CHUNK_SIZE, but for archs that have sg chaining. This limit
340 : * is totally arbitrary, a setting of 2048 will get you at least 8mb ios.
341 : */
342 : #ifdef CONFIG_ARCH_NO_SG_CHAIN
343 : #define SG_MAX_SEGMENTS SG_CHUNK_SIZE
344 : #else
345 : #define SG_MAX_SEGMENTS 2048
346 : #endif
347 :
348 : #ifdef CONFIG_SG_POOL
349 : void sg_free_table_chained(struct sg_table *table,
350 : unsigned nents_first_chunk);
351 : int sg_alloc_table_chained(struct sg_table *table, int nents,
352 : struct scatterlist *first_chunk,
353 : unsigned nents_first_chunk);
354 : #endif
355 :
356 : /*
357 : * sg page iterator
358 : *
359 : * Iterates over sg entries page-by-page. On each successful iteration, you
360 : * can call sg_page_iter_page(@piter) to get the current page.
361 : * @piter->sg will point to the sg holding this page and @piter->sg_pgoffset to
362 : * the page's page offset within the sg. The iteration will stop either when a
363 : * maximum number of sg entries was reached or a terminating sg
364 : * (sg_last(sg) == true) was reached.
365 : */
366 : struct sg_page_iter {
367 : struct scatterlist *sg; /* sg holding the page */
368 : unsigned int sg_pgoffset; /* page offset within the sg */
369 :
370 : /* these are internal states, keep away */
371 : unsigned int __nents; /* remaining sg entries */
372 : int __pg_advance; /* nr pages to advance at the
373 : * next step */
374 : };
375 :
376 : /*
377 : * sg page iterator for DMA addresses
378 : *
379 : * This is the same as sg_page_iter however you can call
380 : * sg_page_iter_dma_address(@dma_iter) to get the page's DMA
381 : * address. sg_page_iter_page() cannot be called on this iterator.
382 : */
383 : struct sg_dma_page_iter {
384 : struct sg_page_iter base;
385 : };
386 :
387 : bool __sg_page_iter_next(struct sg_page_iter *piter);
388 : bool __sg_page_iter_dma_next(struct sg_dma_page_iter *dma_iter);
389 : void __sg_page_iter_start(struct sg_page_iter *piter,
390 : struct scatterlist *sglist, unsigned int nents,
391 : unsigned long pgoffset);
392 : /**
393 : * sg_page_iter_page - get the current page held by the page iterator
394 : * @piter: page iterator holding the page
395 : */
396 0 : static inline struct page *sg_page_iter_page(struct sg_page_iter *piter)
397 : {
398 0 : return nth_page(sg_page(piter->sg), piter->sg_pgoffset);
399 : }
400 :
401 : /**
402 : * sg_page_iter_dma_address - get the dma address of the current page held by
403 : * the page iterator.
404 : * @dma_iter: page iterator holding the page
405 : */
406 : static inline dma_addr_t
407 : sg_page_iter_dma_address(struct sg_dma_page_iter *dma_iter)
408 : {
409 : return sg_dma_address(dma_iter->base.sg) +
410 : (dma_iter->base.sg_pgoffset << PAGE_SHIFT);
411 : }
412 :
413 : /**
414 : * for_each_sg_page - iterate over the pages of the given sg list
415 : * @sglist: sglist to iterate over
416 : * @piter: page iterator to hold current page, sg, sg_pgoffset
417 : * @nents: maximum number of sg entries to iterate over
418 : * @pgoffset: starting page offset (in pages)
419 : *
420 : * Callers may use sg_page_iter_page() to get each page pointer.
421 : * In each loop it operates on PAGE_SIZE unit.
422 : */
423 : #define for_each_sg_page(sglist, piter, nents, pgoffset) \
424 : for (__sg_page_iter_start((piter), (sglist), (nents), (pgoffset)); \
425 : __sg_page_iter_next(piter);)
426 :
427 : /**
428 : * for_each_sg_dma_page - iterate over the pages of the given sg list
429 : * @sglist: sglist to iterate over
430 : * @dma_iter: DMA page iterator to hold current page
431 : * @dma_nents: maximum number of sg entries to iterate over, this is the value
432 : * returned from dma_map_sg
433 : * @pgoffset: starting page offset (in pages)
434 : *
435 : * Callers may use sg_page_iter_dma_address() to get each page's DMA address.
436 : * In each loop it operates on PAGE_SIZE unit.
437 : */
438 : #define for_each_sg_dma_page(sglist, dma_iter, dma_nents, pgoffset) \
439 : for (__sg_page_iter_start(&(dma_iter)->base, sglist, dma_nents, \
440 : pgoffset); \
441 : __sg_page_iter_dma_next(dma_iter);)
442 :
443 : /**
444 : * for_each_sgtable_page - iterate over all pages in the sg_table object
445 : * @sgt: sg_table object to iterate over
446 : * @piter: page iterator to hold current page
447 : * @pgoffset: starting page offset (in pages)
448 : *
449 : * Iterates over the all memory pages in the buffer described by
450 : * a scatterlist stored in the given sg_table object.
451 : * See also for_each_sg_page(). In each loop it operates on PAGE_SIZE unit.
452 : */
453 : #define for_each_sgtable_page(sgt, piter, pgoffset) \
454 : for_each_sg_page((sgt)->sgl, piter, (sgt)->orig_nents, pgoffset)
455 :
456 : /**
457 : * for_each_sgtable_dma_page - iterate over the DMA mapped sg_table object
458 : * @sgt: sg_table object to iterate over
459 : * @dma_iter: DMA page iterator to hold current page
460 : * @pgoffset: starting page offset (in pages)
461 : *
462 : * Iterates over the all DMA mapped pages in the buffer described by
463 : * a scatterlist stored in the given sg_table object.
464 : * See also for_each_sg_dma_page(). In each loop it operates on PAGE_SIZE
465 : * unit.
466 : */
467 : #define for_each_sgtable_dma_page(sgt, dma_iter, pgoffset) \
468 : for_each_sg_dma_page((sgt)->sgl, dma_iter, (sgt)->nents, pgoffset)
469 :
470 :
471 : /*
472 : * Mapping sg iterator
473 : *
474 : * Iterates over sg entries mapping page-by-page. On each successful
475 : * iteration, @miter->page points to the mapped page and
476 : * @miter->length bytes of data can be accessed at @miter->addr. As
477 : * long as an interation is enclosed between start and stop, the user
478 : * is free to choose control structure and when to stop.
479 : *
480 : * @miter->consumed is set to @miter->length on each iteration. It
481 : * can be adjusted if the user can't consume all the bytes in one go.
482 : * Also, a stopped iteration can be resumed by calling next on it.
483 : * This is useful when iteration needs to release all resources and
484 : * continue later (e.g. at the next interrupt).
485 : */
486 :
487 : #define SG_MITER_ATOMIC (1 << 0) /* use kmap_atomic */
488 : #define SG_MITER_TO_SG (1 << 1) /* flush back to phys on unmap */
489 : #define SG_MITER_FROM_SG (1 << 2) /* nop */
490 :
491 : struct sg_mapping_iter {
492 : /* the following three fields can be accessed directly */
493 : struct page *page; /* currently mapped page */
494 : void *addr; /* pointer to the mapped area */
495 : size_t length; /* length of the mapped area */
496 : size_t consumed; /* number of consumed bytes */
497 : struct sg_page_iter piter; /* page iterator */
498 :
499 : /* these are internal states, keep away */
500 : unsigned int __offset; /* offset within page */
501 : unsigned int __remaining; /* remaining bytes on page */
502 : unsigned int __flags;
503 : };
504 :
505 : void sg_miter_start(struct sg_mapping_iter *miter, struct scatterlist *sgl,
506 : unsigned int nents, unsigned int flags);
507 : bool sg_miter_skip(struct sg_mapping_iter *miter, off_t offset);
508 : bool sg_miter_next(struct sg_mapping_iter *miter);
509 : void sg_miter_stop(struct sg_mapping_iter *miter);
510 :
511 : #endif /* _LINUX_SCATTERLIST_H */
|
