compat/nes: Adding pci_zalloc_consistent backport
[compat-rdma/compat.git] / compat / compat-3.11.c
1 #include <linux/export.h>
2 #include <linux/scatterlist.h>
3 #include <linux/highmem.h>
4
5
6 #define sg_mapping_iter LINUX_BACKPORT(sg_mapping_iter)
7 #define sg_page_iter LINUX_BACKPORT(sg_page_iter)
8 #define __sg_page_iter_next LINUX_BACKPORT(__sg_page_iter_next)
9 #define __sg_page_iter_start LINUX_BACKPORT(__sg_page_iter_start)
10 #define sg_page_iter_page LINUX_BACKPORT(sg_page_iter_page)
11 #define sg_page_iter_dma_address LINUX_BACKPORT(sg_page_iter_dma_address)
12
13 #define sg_miter_start LINUX_BACKPORT(sg_miter_start)
14 #define sg_miter_skip LINUX_BACKPORT(sg_miter_skip)
15 #define sg_miter_next LINUX_BACKPORT(sg_miter_next)
16 #define sg_miter_stop LINUX_BACKPORT(sg_miter_stop)
17
18 /*
19  * sg page iterator
20  *
21  * Iterates over sg entries page-by-page.  On each successful iteration,
22  * you can call sg_page_iter_page(@piter) and sg_page_iter_dma_address(@piter)
23  * to get the current page and its dma address. @piter->sg will point to the
24  * sg holding this page and @piter->sg_pgoffset to the page's page offset
25  * within the sg. The iteration will stop either when a maximum number of sg
26  * entries was reached or a terminating sg (sg_last(sg) == true) was reached.
27  */
28 struct sg_page_iter {
29         struct scatterlist      *sg;            /* sg holding the page */
30         unsigned int            sg_pgoffset;    /* page offset within the sg */
31
32         /* these are internal states, keep away */
33         unsigned int            __nents;        /* remaining sg entries */
34         int                     __pg_advance;   /* nr pages to advance at the
35                                                  * next step */
36 };
37
38
39 /*
40  * Mapping sg iterator
41  *
42  * Iterates over sg entries mapping page-by-page.  On each successful
43  * iteration, @miter->page points to the mapped page and
44  * @miter->length bytes of data can be accessed at @miter->addr.  As
45  * long as an interation is enclosed between start and stop, the user
46  * is free to choose control structure and when to stop.
47  *
48  * @miter->consumed is set to @miter->length on each iteration.  It
49  * can be adjusted if the user can't consume all the bytes in one go.
50  * Also, a stopped iteration can be resumed by calling next on it.
51  * This is useful when iteration needs to release all resources and
52  * continue later (e.g. at the next interrupt).
53  */
54
55 #define SG_MITER_ATOMIC         (1 << 0)        /* use kmap_atomic */
56 #define SG_MITER_TO_SG          (1 << 1)        /* flush back to phys on unmap*/
57 #define SG_MITER_FROM_SG        (1 << 2)        /* nop */
58
59 struct sg_mapping_iter {
60         /* the following three fields can be accessed directly */
61         struct page             *page;          /* currently mapped page */
62         void                    *addr;          /* pointer to the mapped area */
63         size_t                  length;         /* length of the mapped area */
64         size_t                  consumed;       /* number of consumed bytes */
65         struct sg_page_iter     piter;          /* page iterator */
66
67         /* these are internal states, keep away */
68         unsigned int            __offset;       /* offset within page */
69         unsigned int            __remaining;    /* remaining bytes on page */
70         unsigned int            __flags;
71 };
72
73 void sg_miter_stop(struct sg_mapping_iter *miter);
74
75
76 /**
77  * sg_page_iter_page - get the current page held by the page iterator
78  * @piter:      page iterator holding the page
79  */
80 static inline struct page *sg_page_iter_page(struct sg_page_iter *piter)
81 {
82         return nth_page(sg_page(piter->sg), piter->sg_pgoffset);
83 }
84
85 /**
86  * sg_page_iter_dma_address - get the dma address of the current page held by
87  * the page iterator.
88  * @piter:      page iterator holding the page
89  */
90 static inline dma_addr_t sg_page_iter_dma_address(struct sg_page_iter *piter)
91 {
92         return sg_dma_address(piter->sg) + (piter->sg_pgoffset << PAGE_SHIFT);
93 }
94
95 void __sg_page_iter_start(struct sg_page_iter *piter,
96                           struct scatterlist *sglist, unsigned int nents,
97                           unsigned long pgoffset)
98 {
99         piter->__pg_advance = 0;
100         piter->__nents = nents;
101
102         piter->sg = sglist;
103         piter->sg_pgoffset = pgoffset;
104 }
105 /* EXPORT_SYMBOL(__sg_page_iter_start); */
106
107 static int sg_page_count(struct scatterlist *sg)
108 {
109         return PAGE_ALIGN(sg->offset + sg->length) >> PAGE_SHIFT;
110 }
111
112 bool __sg_page_iter_next(struct sg_page_iter *piter)
113 {
114         if (!piter->__nents || !piter->sg)
115                 return false;
116
117         piter->sg_pgoffset += piter->__pg_advance;
118         piter->__pg_advance = 1;
119
120         while (piter->sg_pgoffset >= sg_page_count(piter->sg)) {
121                 piter->sg_pgoffset -= sg_page_count(piter->sg);
122                 piter->sg = sg_next(piter->sg);
123                 if (!--piter->__nents || !piter->sg)
124                         return false;
125         }
126
127         return true;
128 }
129 /* EXPORT_SYMBOL(__sg_page_iter_next); */
130
131 /**
132  * sg_miter_start - start mapping iteration over a sg list
133  * @miter: sg mapping iter to be started
134  * @sgl: sg list to iterate over
135  * @nents: number of sg entries
136  *
137  * Description:
138  *   Starts mapping iterator @miter.
139  *
140  * Context:
141  *   Don't care.
142  */
143 void sg_miter_start(struct sg_mapping_iter *miter, struct scatterlist *sgl,
144                     unsigned int nents, unsigned int flags)
145 {
146         memset(miter, 0, sizeof(struct sg_mapping_iter));
147
148         __sg_page_iter_start(&miter->piter, sgl, nents, 0);
149         WARN_ON(!(flags & (SG_MITER_TO_SG | SG_MITER_FROM_SG)));
150         miter->__flags = flags;
151 }
152 /* EXPORT_SYMBOL(sg_miter_start); */
153
154 static bool sg_miter_get_next_page(struct sg_mapping_iter *miter)
155 {
156         if (!miter->__remaining) {
157                 struct scatterlist *sg;
158                 unsigned long pgoffset;
159
160                 if (!__sg_page_iter_next(&miter->piter))
161                         return false;
162
163                 sg = miter->piter.sg;
164                 pgoffset = miter->piter.sg_pgoffset;
165
166                 miter->__offset = pgoffset ? 0 : sg->offset;
167                 miter->__remaining = sg->offset + sg->length -
168                                 (pgoffset << PAGE_SHIFT) - miter->__offset;
169                 miter->__remaining = min_t(unsigned long, miter->__remaining,
170                                            PAGE_SIZE - miter->__offset);
171         }
172
173         return true;
174 }
175
176 /**
177  * sg_miter_skip - reposition mapping iterator
178  * @miter: sg mapping iter to be skipped
179  * @offset: number of bytes to plus the current location
180  *
181  * Description:
182  *   Sets the offset of @miter to its current location plus @offset bytes.
183  *   If mapping iterator @miter has been proceeded by sg_miter_next(), this
184  *   stops @miter.
185  *
186  * Context:
187  *   Don't care if @miter is stopped, or not proceeded yet.
188  *   Otherwise, preemption disabled if the SG_MITER_ATOMIC is set.
189  *
190  * Returns:
191  *   true if @miter contains the valid mapping.  false if end of sg
192  *   list is reached.
193  */
194 bool sg_miter_skip(struct sg_mapping_iter *miter, off_t offset)
195 {
196         sg_miter_stop(miter);
197
198         while (offset) {
199                 off_t consumed;
200
201                 if (!sg_miter_get_next_page(miter))
202                         return false;
203
204                 consumed = min_t(off_t, offset, miter->__remaining);
205                 miter->__offset += consumed;
206                 miter->__remaining -= consumed;
207                 offset -= consumed;
208         }
209
210         return true;
211 }
212 /* EXPORT_SYMBOL(sg_miter_skip); */
213
214 /**
215  * sg_miter_next - proceed mapping iterator to the next mapping
216  * @miter: sg mapping iter to proceed
217  *
218  * Description:
219  *   Proceeds @miter to the next mapping.  @miter should have been started
220  *   using sg_miter_start().  On successful return, @miter->page,
221  *   @miter->addr and @miter->length point to the current mapping.
222  *
223  * Context:
224  *   Preemption disabled if SG_MITER_ATOMIC.  Preemption must stay disabled
225  *   till @miter is stopped.  May sleep if !SG_MITER_ATOMIC.
226  *
227  * Returns:
228  *   true if @miter contains the next mapping.  false if end of sg
229  *   list is reached.
230  */
231 bool sg_miter_next(struct sg_mapping_iter *miter)
232 {
233         sg_miter_stop(miter);
234
235         /*
236          * Get to the next page if necessary.
237          * __remaining, __offset is adjusted by sg_miter_stop
238          */
239         if (!sg_miter_get_next_page(miter))
240                 return false;
241
242         miter->page = sg_page_iter_page(&miter->piter);
243         miter->consumed = miter->length = miter->__remaining;
244
245         if (miter->__flags & SG_MITER_ATOMIC)
246 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 4, 0))
247                 miter->addr = kmap_atomic(miter->page, 0) + miter->__offset;
248 #else
249                 miter->addr = kmap_atomic(miter->page) + miter->__offset;
250 #endif
251         else
252                 miter->addr = kmap(miter->page) + miter->__offset;
253
254         return true;
255 }
256 /* EXPORT_SYMBOL(sg_miter_next); */
257
258 /**
259  * sg_miter_stop - stop mapping iteration
260  * @miter: sg mapping iter to be stopped
261  *
262  * Description:
263  *   Stops mapping iterator @miter.  @miter should have been started
264  *   started using sg_miter_start().  A stopped iteration can be
265  *   resumed by calling sg_miter_next() on it.  This is useful when
266  *   resources (kmap) need to be released during iteration.
267  *
268  * Context:
269  *   Preemption disabled if the SG_MITER_ATOMIC is set.  Don't care
270  *   otherwise.
271  */
272 void sg_miter_stop(struct sg_mapping_iter *miter)
273 {
274         WARN_ON(miter->consumed > miter->length);
275
276         /* drop resources from the last iteration */
277         if (miter->addr) {
278                 miter->__offset += miter->consumed;
279                 miter->__remaining -= miter->consumed;
280
281                 if ((miter->__flags & SG_MITER_TO_SG) &&
282                     !PageSlab(miter->page))
283                         flush_kernel_dcache_page(miter->page);
284
285                 if (miter->__flags & SG_MITER_ATOMIC) {
286                         WARN_ON_ONCE(preemptible());
287 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 4, 0))
288                         kunmap_atomic(miter->addr, 0);
289 #else
290                         kunmap_atomic(miter->addr);
291 #endif
292                 } else
293                         kunmap(miter->page);
294
295                 miter->page = NULL;
296                 miter->addr = NULL;
297                 miter->length = 0;
298                 miter->consumed = 0;
299         }
300 }
301 /* EXPORT_SYMBOL(sg_miter_stop); */
302
303 /**
304  * sg_copy_buffer - Copy data between a linear buffer and an SG list
305  * @sgl:                 The SG list
306  * @nents:               Number of SG entries
307  * @buf:                 Where to copy from
308  * @buflen:              The number of bytes to copy
309  * @skip:                Number of bytes to skip before copying
310  * @to_buffer:           transfer direction (true == from an sg list to a
311  *                       buffer, false == from a buffer to an sg list
312  *
313  * Returns the number of copied bytes.
314  *
315  **/
316 static size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents,
317                              void *buf, size_t buflen, off_t skip,
318                              bool to_buffer)
319 {
320         unsigned int offset = 0;
321         struct sg_mapping_iter miter;
322         unsigned long flags;
323         unsigned int sg_flags = SG_MITER_ATOMIC;
324
325         if (to_buffer)
326                 sg_flags |= SG_MITER_FROM_SG;
327         else
328                 sg_flags |= SG_MITER_TO_SG;
329
330         sg_miter_start(&miter, sgl, nents, sg_flags);
331
332         if (!sg_miter_skip(&miter, skip))
333                 return false;
334
335         local_irq_save(flags);
336
337         while (sg_miter_next(&miter) && offset < buflen) {
338                 unsigned int len;
339
340                 len = min(miter.length, buflen - offset);
341
342                 if (to_buffer)
343                         memcpy(buf + offset, miter.addr, len);
344                 else
345                         memcpy(miter.addr, buf + offset, len);
346
347                 offset += len;
348         }
349
350         sg_miter_stop(&miter);
351
352         local_irq_restore(flags);
353         return offset;
354 }
355
356 /**
357  * sg_copy_from_buffer - Copy from a linear buffer to an SG list
358  * @sgl:                 The SG list
359  * @nents:               Number of SG entries
360  * @buf:                 Where to copy from
361  * @buflen:              The number of bytes to copy
362  *
363  * Returns the number of copied bytes.
364  *
365  **/
366 #define sg_copy_from_buffer LINUX_BACKPORT(sg_copy_from_buffer)
367 size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
368                            void *buf, size_t buflen)
369 {
370         return sg_copy_buffer(sgl, nents, buf, buflen, 0, false);
371 }
372 EXPORT_SYMBOL(sg_copy_from_buffer);
373
374 /**
375  * sg_copy_to_buffer - Copy from an SG list to a linear buffer
376  * @sgl:                 The SG list
377  * @nents:               Number of SG entries
378  * @buf:                 Where to copy to
379  * @buflen:              The number of bytes to copy
380  *
381  * Returns the number of copied bytes.
382  *
383  **/
384 #define sg_copy_to_buffer LINUX_BACKPORT(sg_copy_to_buffer)
385 size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
386                          void *buf, size_t buflen)
387 {
388         return sg_copy_buffer(sgl, nents, buf, buflen, 0, true);
389 }
390 EXPORT_SYMBOL(sg_copy_to_buffer);
391
392 /**
393  * sg_pcopy_from_buffer - Copy from a linear buffer to an SG list
394  * @sgl:                 The SG list
395  * @nents:               Number of SG entries
396  * @buf:                 Where to copy from
397  * @skip:                Number of bytes to skip before copying
398  * @buflen:              The number of bytes to copy
399  *
400  * Returns the number of copied bytes.
401  *
402  **/
403 #define sg_pcopy_from_buffer LINUX_BACKPORT(sg_pcopy_from_buffer)
404 size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
405                             void *buf, size_t buflen, off_t skip)
406 {
407         return sg_copy_buffer(sgl, nents, buf, buflen, skip, false);
408 }
409 EXPORT_SYMBOL(sg_pcopy_from_buffer);
410
411 /**
412  * sg_pcopy_to_buffer - Copy from an SG list to a linear buffer
413  * @sgl:                 The SG list
414  * @nents:               Number of SG entries
415  * @buf:                 Where to copy to
416  * @skip:                Number of bytes to skip before copying
417  * @buflen:              The number of bytes to copy
418  *
419  * Returns the number of copied bytes.
420  *
421  **/
422 #define sg_pcopy_to_buffer LINUX_BACKPORT(sg_pcopy_to_buffer)
423 size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
424                           void *buf, size_t buflen, off_t skip)
425 {
426         return sg_copy_buffer(sgl, nents, buf, buflen, skip, true);
427 }
428 EXPORT_SYMBOL(sg_pcopy_to_buffer);