compat: backport kfifo
[~emulex/for-vlad/old/compat.git] / include / linux / kfifo.h
1 #include <linux/version.h>
2 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
3 #include_next <linux/kfifo.h>
4 #else
5 /*
6  * A generic kernel FIFO implementation
7  *
8  * Copyright (C) 2009/2010 Stefani Seibold <stefani@seibold.net>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  *
24  */
25
26 #ifndef _LINUX_KFIFO_H
27 #define _LINUX_KFIFO_H
28
29 /*
30  * How to porting drivers to the new generic FIFO API:
31  *
32  * - Modify the declaration of the "struct kfifo *" object into a
33  *   in-place "struct kfifo" object
34  * - Init the in-place object with kfifo_alloc() or kfifo_init()
35  *   Note: The address of the in-place "struct kfifo" object must be
36  *   passed as the first argument to this functions
37  * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
38  *   into kfifo_out
39  * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get
40  *   into kfifo_out_spinlocked
41  *   Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
42  *   must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked
43  *   as the last parameter
44  * - The formerly __kfifo_* functions are renamed into kfifo_*
45  */
46
47 /*
48  * Note about locking : There is no locking required until only * one reader
49  * and one writer is using the fifo and no kfifo_reset() will be * called
50  *  kfifo_reset_out() can be safely used, until it will be only called
51  * in the reader thread.
52  *  For multiple writer and one reader there is only a need to lock the writer.
53  * And vice versa for only one writer and multiple reader there is only a need
54  * to lock the reader.
55  */
56
57 #include <linux/kernel.h>
58 #include <linux/spinlock.h>
59 #include <linux/stddef.h>
60 #include <linux/scatterlist.h>
61
62 struct __kfifo {
63         unsigned int    in;
64         unsigned int    out;
65         unsigned int    mask;
66         unsigned int    esize;
67         void            *data;
68 };
69
70 #define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \
71         union { \
72                 struct __kfifo  kfifo; \
73                 datatype        *type; \
74                 char            (*rectype)[recsize]; \
75                 ptrtype         *ptr; \
76                 const ptrtype   *ptr_const; \
77         }
78
79 #define __STRUCT_KFIFO(type, size, recsize, ptrtype) \
80 { \
81         __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
82         type            buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \
83 }
84
85 #define STRUCT_KFIFO(type, size) \
86         struct __STRUCT_KFIFO(type, size, 0, type)
87
88 #define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \
89 { \
90         __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
91         type            buf[0]; \
92 }
93
94 #define STRUCT_KFIFO_PTR(type) \
95         struct __STRUCT_KFIFO_PTR(type, 0, type)
96
97 /*
98  * define compatibility "struct kfifo" for dynamic allocated fifos
99  */
100 struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void);
101
102 #define STRUCT_KFIFO_REC_1(size) \
103         struct __STRUCT_KFIFO(unsigned char, size, 1, void)
104
105 #define STRUCT_KFIFO_REC_2(size) \
106         struct __STRUCT_KFIFO(unsigned char, size, 2, void)
107
108 /*
109  * define kfifo_rec types
110  */
111 struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void);
112 struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void);
113
114 /*
115  * helper macro to distinguish between real in place fifo where the fifo
116  * array is a part of the structure and the fifo type where the array is
117  * outside of the fifo structure.
118  */
119 #define __is_kfifo_ptr(fifo)    (sizeof(*fifo) == sizeof(struct __kfifo))
120
121 /**
122  * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object
123  * @fifo: name of the declared fifo
124  * @type: type of the fifo elements
125  */
126 #define DECLARE_KFIFO_PTR(fifo, type)   STRUCT_KFIFO_PTR(type) fifo
127
128 /**
129  * DECLARE_KFIFO - macro to declare a fifo object
130  * @fifo: name of the declared fifo
131  * @type: type of the fifo elements
132  * @size: the number of elements in the fifo, this must be a power of 2
133  */
134 #define DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo
135
136 /**
137  * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO
138  * @fifo: name of the declared fifo datatype
139  */
140 #define INIT_KFIFO(fifo) \
141 (void)({ \
142         typeof(&(fifo)) __tmp = &(fifo); \
143         struct __kfifo *__kfifo = &__tmp->kfifo; \
144         __kfifo->in = 0; \
145         __kfifo->out = 0; \
146         __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\
147         __kfifo->esize = sizeof(*__tmp->buf); \
148         __kfifo->data = __is_kfifo_ptr(__tmp) ?  NULL : __tmp->buf; \
149 })
150
151 /**
152  * DEFINE_KFIFO - macro to define and initialize a fifo
153  * @fifo: name of the declared fifo datatype
154  * @type: type of the fifo elements
155  * @size: the number of elements in the fifo, this must be a power of 2
156  *
157  * Note: the macro can be used for global and local fifo data type variables.
158  */
159 #define DEFINE_KFIFO(fifo, type, size) \
160         DECLARE_KFIFO(fifo, type, size) = \
161         (typeof(fifo)) { \
162                 { \
163                         { \
164                         .in     = 0, \
165                         .out    = 0, \
166                         .mask   = __is_kfifo_ptr(&(fifo)) ? \
167                                   0 : \
168                                   ARRAY_SIZE((fifo).buf) - 1, \
169                         .esize  = sizeof(*(fifo).buf), \
170                         .data   = __is_kfifo_ptr(&(fifo)) ? \
171                                 NULL : \
172                                 (fifo).buf, \
173                         } \
174                 } \
175         }
176
177
178 static inline unsigned int __must_check
179 __kfifo_uint_must_check_helper(unsigned int val)
180 {
181         return val;
182 }
183
184 static inline int __must_check
185 __kfifo_int_must_check_helper(int val)
186 {
187         return val;
188 }
189
190 /**
191  * kfifo_initialized - Check if the fifo is initialized
192  * @fifo: address of the fifo to check
193  *
194  * Return %true if fifo is initialized, otherwise %false.
195  * Assumes the fifo was 0 before.
196  */
197 #define kfifo_initialized(fifo) ((fifo)->kfifo.mask)
198
199 /**
200  * kfifo_esize - returns the size of the element managed by the fifo
201  * @fifo: address of the fifo to be used
202  */
203 #define kfifo_esize(fifo)       ((fifo)->kfifo.esize)
204
205 /**
206  * kfifo_recsize - returns the size of the record length field
207  * @fifo: address of the fifo to be used
208  */
209 #define kfifo_recsize(fifo)     (sizeof(*(fifo)->rectype))
210
211 /**
212  * kfifo_size - returns the size of the fifo in elements
213  * @fifo: address of the fifo to be used
214  */
215 #define kfifo_size(fifo)        ((fifo)->kfifo.mask + 1)
216
217 /**
218  * kfifo_reset - removes the entire fifo content
219  * @fifo: address of the fifo to be used
220  *
221  * Note: usage of kfifo_reset() is dangerous. It should be only called when the
222  * fifo is exclusived locked or when it is secured that no other thread is
223  * accessing the fifo.
224  */
225 #define kfifo_reset(fifo) \
226 (void)({ \
227         typeof((fifo) + 1) __tmp = (fifo); \
228         __tmp->kfifo.in = __tmp->kfifo.out = 0; \
229 })
230
231 /**
232  * kfifo_reset_out - skip fifo content
233  * @fifo: address of the fifo to be used
234  *
235  * Note: The usage of kfifo_reset_out() is safe until it will be only called
236  * from the reader thread and there is only one concurrent reader. Otherwise
237  * it is dangerous and must be handled in the same way as kfifo_reset().
238  */
239 #define kfifo_reset_out(fifo)   \
240 (void)({ \
241         typeof((fifo) + 1) __tmp = (fifo); \
242         __tmp->kfifo.out = __tmp->kfifo.in; \
243 })
244
245 /**
246  * kfifo_len - returns the number of used elements in the fifo
247  * @fifo: address of the fifo to be used
248  */
249 #define kfifo_len(fifo) \
250 ({ \
251         typeof((fifo) + 1) __tmpl = (fifo); \
252         __tmpl->kfifo.in - __tmpl->kfifo.out; \
253 })
254
255 /**
256  * kfifo_is_empty - returns true if the fifo is empty
257  * @fifo: address of the fifo to be used
258  */
259 #define kfifo_is_empty(fifo) \
260 ({ \
261         typeof((fifo) + 1) __tmpq = (fifo); \
262         __tmpq->kfifo.in == __tmpq->kfifo.out; \
263 })
264
265 /**
266  * kfifo_is_full - returns true if the fifo is full
267  * @fifo: address of the fifo to be used
268  */
269 #define kfifo_is_full(fifo) \
270 ({ \
271         typeof((fifo) + 1) __tmpq = (fifo); \
272         kfifo_len(__tmpq) > __tmpq->kfifo.mask; \
273 })
274
275 /**
276  * kfifo_avail - returns the number of unused elements in the fifo
277  * @fifo: address of the fifo to be used
278  */
279 #define kfifo_avail(fifo) \
280 __kfifo_uint_must_check_helper( \
281 ({ \
282         typeof((fifo) + 1) __tmpq = (fifo); \
283         const size_t __recsize = sizeof(*__tmpq->rectype); \
284         unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \
285         (__recsize) ? ((__avail <= __recsize) ? 0 : \
286         __kfifo_max_r(__avail - __recsize, __recsize)) : \
287         __avail; \
288 }) \
289 )
290
291 /**
292  * kfifo_skip - skip output data
293  * @fifo: address of the fifo to be used
294  */
295 #define kfifo_skip(fifo) \
296 (void)({ \
297         typeof((fifo) + 1) __tmp = (fifo); \
298         const size_t __recsize = sizeof(*__tmp->rectype); \
299         struct __kfifo *__kfifo = &__tmp->kfifo; \
300         if (__recsize) \
301                 __kfifo_skip_r(__kfifo, __recsize); \
302         else \
303                 __kfifo->out++; \
304 })
305
306 /**
307  * kfifo_peek_len - gets the size of the next fifo record
308  * @fifo: address of the fifo to be used
309  *
310  * This function returns the size of the next fifo record in number of bytes.
311  */
312 #define kfifo_peek_len(fifo) \
313 __kfifo_uint_must_check_helper( \
314 ({ \
315         typeof((fifo) + 1) __tmp = (fifo); \
316         const size_t __recsize = sizeof(*__tmp->rectype); \
317         struct __kfifo *__kfifo = &__tmp->kfifo; \
318         (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \
319         __kfifo_len_r(__kfifo, __recsize); \
320 }) \
321 )
322
323 /**
324  * kfifo_alloc - dynamically allocates a new fifo buffer
325  * @fifo: pointer to the fifo
326  * @size: the number of elements in the fifo, this must be a power of 2
327  * @gfp_mask: get_free_pages mask, passed to kmalloc()
328  *
329  * This macro dynamically allocates a new fifo buffer.
330  *
331  * The numer of elements will be rounded-up to a power of 2.
332  * The fifo will be release with kfifo_free().
333  * Return 0 if no error, otherwise an error code.
334  */
335 #define kfifo_alloc(fifo, size, gfp_mask) \
336 __kfifo_int_must_check_helper( \
337 ({ \
338         typeof((fifo) + 1) __tmp = (fifo); \
339         struct __kfifo *__kfifo = &__tmp->kfifo; \
340         __is_kfifo_ptr(__tmp) ? \
341         __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \
342         -EINVAL; \
343 }) \
344 )
345
346 /**
347  * kfifo_free - frees the fifo
348  * @fifo: the fifo to be freed
349  */
350 #define kfifo_free(fifo) \
351 ({ \
352         typeof((fifo) + 1) __tmp = (fifo); \
353         struct __kfifo *__kfifo = &__tmp->kfifo; \
354         if (__is_kfifo_ptr(__tmp)) \
355                 __kfifo_free(__kfifo); \
356 })
357
358 /**
359  * kfifo_init - initialize a fifo using a preallocated buffer
360  * @fifo: the fifo to assign the buffer
361  * @buffer: the preallocated buffer to be used
362  * @size: the size of the internal buffer, this have to be a power of 2
363  *
364  * This macro initialize a fifo using a preallocated buffer.
365  *
366  * The numer of elements will be rounded-up to a power of 2.
367  * Return 0 if no error, otherwise an error code.
368  */
369 #define kfifo_init(fifo, buffer, size) \
370 ({ \
371         typeof((fifo) + 1) __tmp = (fifo); \
372         struct __kfifo *__kfifo = &__tmp->kfifo; \
373         __is_kfifo_ptr(__tmp) ? \
374         __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \
375         -EINVAL; \
376 })
377
378 /**
379  * kfifo_put - put data into the fifo
380  * @fifo: address of the fifo to be used
381  * @val: the data to be added
382  *
383  * This macro copies the given value into the fifo.
384  * It returns 0 if the fifo was full. Otherwise it returns the number
385  * processed elements.
386  *
387  * Note that with only one concurrent reader and one concurrent
388  * writer, you don't need extra locking to use these macro.
389  */
390 #define kfifo_put(fifo, val) \
391 ({ \
392         typeof((fifo) + 1) __tmp = (fifo); \
393         typeof((val) + 1) __val = (val); \
394         unsigned int __ret; \
395         const size_t __recsize = sizeof(*__tmp->rectype); \
396         struct __kfifo *__kfifo = &__tmp->kfifo; \
397         if (0) { \
398                 typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \
399                 __dummy = (typeof(__val))NULL; \
400         } \
401         if (__recsize) \
402                 __ret = __kfifo_in_r(__kfifo, __val, sizeof(*__val), \
403                         __recsize); \
404         else { \
405                 __ret = !kfifo_is_full(__tmp); \
406                 if (__ret) { \
407                         (__is_kfifo_ptr(__tmp) ? \
408                         ((typeof(__tmp->type))__kfifo->data) : \
409                         (__tmp->buf) \
410                         )[__kfifo->in & __tmp->kfifo.mask] = \
411                                 *(typeof(__tmp->type))__val; \
412                         smp_wmb(); \
413                         __kfifo->in++; \
414                 } \
415         } \
416         __ret; \
417 })
418
419 /**
420  * kfifo_get - get data from the fifo
421  * @fifo: address of the fifo to be used
422  * @val: the var where to store the data to be added
423  *
424  * This macro reads the data from the fifo.
425  * It returns 0 if the fifo was empty. Otherwise it returns the number
426  * processed elements.
427  *
428  * Note that with only one concurrent reader and one concurrent
429  * writer, you don't need extra locking to use these macro.
430  */
431 #define kfifo_get(fifo, val) \
432 __kfifo_uint_must_check_helper( \
433 ({ \
434         typeof((fifo) + 1) __tmp = (fifo); \
435         typeof((val) + 1) __val = (val); \
436         unsigned int __ret; \
437         const size_t __recsize = sizeof(*__tmp->rectype); \
438         struct __kfifo *__kfifo = &__tmp->kfifo; \
439         if (0) \
440                 __val = (typeof(__tmp->ptr))0; \
441         if (__recsize) \
442                 __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \
443                         __recsize); \
444         else { \
445                 __ret = !kfifo_is_empty(__tmp); \
446                 if (__ret) { \
447                         *(typeof(__tmp->type))__val = \
448                                 (__is_kfifo_ptr(__tmp) ? \
449                                 ((typeof(__tmp->type))__kfifo->data) : \
450                                 (__tmp->buf) \
451                                 )[__kfifo->out & __tmp->kfifo.mask]; \
452                         smp_wmb(); \
453                         __kfifo->out++; \
454                 } \
455         } \
456         __ret; \
457 }) \
458 )
459
460 /**
461  * kfifo_peek - get data from the fifo without removing
462  * @fifo: address of the fifo to be used
463  * @val: the var where to store the data to be added
464  *
465  * This reads the data from the fifo without removing it from the fifo.
466  * It returns 0 if the fifo was empty. Otherwise it returns the number
467  * processed elements.
468  *
469  * Note that with only one concurrent reader and one concurrent
470  * writer, you don't need extra locking to use these macro.
471  */
472 #define kfifo_peek(fifo, val) \
473 __kfifo_uint_must_check_helper( \
474 ({ \
475         typeof((fifo) + 1) __tmp = (fifo); \
476         typeof((val) + 1) __val = (val); \
477         unsigned int __ret; \
478         const size_t __recsize = sizeof(*__tmp->rectype); \
479         struct __kfifo *__kfifo = &__tmp->kfifo; \
480         if (0) \
481                 __val = (typeof(__tmp->ptr))NULL; \
482         if (__recsize) \
483                 __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \
484                         __recsize); \
485         else { \
486                 __ret = !kfifo_is_empty(__tmp); \
487                 if (__ret) { \
488                         *(typeof(__tmp->type))__val = \
489                                 (__is_kfifo_ptr(__tmp) ? \
490                                 ((typeof(__tmp->type))__kfifo->data) : \
491                                 (__tmp->buf) \
492                                 )[__kfifo->out & __tmp->kfifo.mask]; \
493                         smp_wmb(); \
494                 } \
495         } \
496         __ret; \
497 }) \
498 )
499
500 /**
501  * kfifo_in - put data into the fifo
502  * @fifo: address of the fifo to be used
503  * @buf: the data to be added
504  * @n: number of elements to be added
505  *
506  * This macro copies the given buffer into the fifo and returns the
507  * number of copied elements.
508  *
509  * Note that with only one concurrent reader and one concurrent
510  * writer, you don't need extra locking to use these macro.
511  */
512 #define kfifo_in(fifo, buf, n) \
513 ({ \
514         typeof((fifo) + 1) __tmp = (fifo); \
515         typeof((buf) + 1) __buf = (buf); \
516         unsigned long __n = (n); \
517         const size_t __recsize = sizeof(*__tmp->rectype); \
518         struct __kfifo *__kfifo = &__tmp->kfifo; \
519         if (0) { \
520                 typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \
521                 __dummy = (typeof(__buf))NULL; \
522         } \
523         (__recsize) ?\
524         __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \
525         __kfifo_in(__kfifo, __buf, __n); \
526 })
527
528 /**
529  * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking
530  * @fifo: address of the fifo to be used
531  * @buf: the data to be added
532  * @n: number of elements to be added
533  * @lock: pointer to the spinlock to use for locking
534  *
535  * This macro copies the given values buffer into the fifo and returns the
536  * number of copied elements.
537  */
538 #define kfifo_in_spinlocked(fifo, buf, n, lock) \
539 ({ \
540         unsigned long __flags; \
541         unsigned int __ret; \
542         spin_lock_irqsave(lock, __flags); \
543         __ret = kfifo_in(fifo, buf, n); \
544         spin_unlock_irqrestore(lock, __flags); \
545         __ret; \
546 })
547
548 /* alias for kfifo_in_spinlocked, will be removed in a future release */
549 #define kfifo_in_locked(fifo, buf, n, lock) \
550                 kfifo_in_spinlocked(fifo, buf, n, lock)
551
552 /**
553  * kfifo_out - get data from the fifo
554  * @fifo: address of the fifo to be used
555  * @buf: pointer to the storage buffer
556  * @n: max. number of elements to get
557  *
558  * This macro get some data from the fifo and return the numbers of elements
559  * copied.
560  *
561  * Note that with only one concurrent reader and one concurrent
562  * writer, you don't need extra locking to use these macro.
563  */
564 #define kfifo_out(fifo, buf, n) \
565 __kfifo_uint_must_check_helper( \
566 ({ \
567         typeof((fifo) + 1) __tmp = (fifo); \
568         typeof((buf) + 1) __buf = (buf); \
569         unsigned long __n = (n); \
570         const size_t __recsize = sizeof(*__tmp->rectype); \
571         struct __kfifo *__kfifo = &__tmp->kfifo; \
572         if (0) { \
573                 typeof(__tmp->ptr) __dummy = NULL; \
574                 __buf = __dummy; \
575         } \
576         (__recsize) ?\
577         __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \
578         __kfifo_out(__kfifo, __buf, __n); \
579 }) \
580 )
581
582 /**
583  * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking
584  * @fifo: address of the fifo to be used
585  * @buf: pointer to the storage buffer
586  * @n: max. number of elements to get
587  * @lock: pointer to the spinlock to use for locking
588  *
589  * This macro get the data from the fifo and return the numbers of elements
590  * copied.
591  */
592 #define kfifo_out_spinlocked(fifo, buf, n, lock) \
593 __kfifo_uint_must_check_helper( \
594 ({ \
595         unsigned long __flags; \
596         unsigned int __ret; \
597         spin_lock_irqsave(lock, __flags); \
598         __ret = kfifo_out(fifo, buf, n); \
599         spin_unlock_irqrestore(lock, __flags); \
600         __ret; \
601 }) \
602 )
603
604 /* alias for kfifo_out_spinlocked, will be removed in a future release */
605 #define kfifo_out_locked(fifo, buf, n, lock) \
606                 kfifo_out_spinlocked(fifo, buf, n, lock)
607
608 /**
609  * kfifo_from_user - puts some data from user space into the fifo
610  * @fifo: address of the fifo to be used
611  * @from: pointer to the data to be added
612  * @len: the length of the data to be added
613  * @copied: pointer to output variable to store the number of copied bytes
614  *
615  * This macro copies at most @len bytes from the @from into the
616  * fifo, depending of the available space and returns -EFAULT/0.
617  *
618  * Note that with only one concurrent reader and one concurrent
619  * writer, you don't need extra locking to use these macro.
620  */
621 #define kfifo_from_user(fifo, from, len, copied) \
622 __kfifo_uint_must_check_helper( \
623 ({ \
624         typeof((fifo) + 1) __tmp = (fifo); \
625         const void __user *__from = (from); \
626         unsigned int __len = (len); \
627         unsigned int *__copied = (copied); \
628         const size_t __recsize = sizeof(*__tmp->rectype); \
629         struct __kfifo *__kfifo = &__tmp->kfifo; \
630         (__recsize) ? \
631         __kfifo_from_user_r(__kfifo, __from, __len,  __copied, __recsize) : \
632         __kfifo_from_user(__kfifo, __from, __len, __copied); \
633 }) \
634 )
635
636 /**
637  * kfifo_to_user - copies data from the fifo into user space
638  * @fifo: address of the fifo to be used
639  * @to: where the data must be copied
640  * @len: the size of the destination buffer
641  * @copied: pointer to output variable to store the number of copied bytes
642  *
643  * This macro copies at most @len bytes from the fifo into the
644  * @to buffer and returns -EFAULT/0.
645  *
646  * Note that with only one concurrent reader and one concurrent
647  * writer, you don't need extra locking to use these macro.
648  */
649 #define kfifo_to_user(fifo, to, len, copied) \
650 __kfifo_uint_must_check_helper( \
651 ({ \
652         typeof((fifo) + 1) __tmp = (fifo); \
653         void __user *__to = (to); \
654         unsigned int __len = (len); \
655         unsigned int *__copied = (copied); \
656         const size_t __recsize = sizeof(*__tmp->rectype); \
657         struct __kfifo *__kfifo = &__tmp->kfifo; \
658         (__recsize) ? \
659         __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \
660         __kfifo_to_user(__kfifo, __to, __len, __copied); \
661 }) \
662 )
663
664 /**
665  * kfifo_dma_in_prepare - setup a scatterlist for DMA input
666  * @fifo: address of the fifo to be used
667  * @sgl: pointer to the scatterlist array
668  * @nents: number of entries in the scatterlist array
669  * @len: number of elements to transfer
670  *
671  * This macro fills a scatterlist for DMA input.
672  * It returns the number entries in the scatterlist array.
673  *
674  * Note that with only one concurrent reader and one concurrent
675  * writer, you don't need extra locking to use these macros.
676  */
677 #define kfifo_dma_in_prepare(fifo, sgl, nents, len) \
678 ({ \
679         typeof((fifo) + 1) __tmp = (fifo); \
680         struct scatterlist *__sgl = (sgl); \
681         int __nents = (nents); \
682         unsigned int __len = (len); \
683         const size_t __recsize = sizeof(*__tmp->rectype); \
684         struct __kfifo *__kfifo = &__tmp->kfifo; \
685         (__recsize) ? \
686         __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
687         __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \
688 })
689
690 /**
691  * kfifo_dma_in_finish - finish a DMA IN operation
692  * @fifo: address of the fifo to be used
693  * @len: number of bytes to received
694  *
695  * This macro finish a DMA IN operation. The in counter will be updated by
696  * the len parameter. No error checking will be done.
697  *
698  * Note that with only one concurrent reader and one concurrent
699  * writer, you don't need extra locking to use these macros.
700  */
701 #define kfifo_dma_in_finish(fifo, len) \
702 (void)({ \
703         typeof((fifo) + 1) __tmp = (fifo); \
704         unsigned int __len = (len); \
705         const size_t __recsize = sizeof(*__tmp->rectype); \
706         struct __kfifo *__kfifo = &__tmp->kfifo; \
707         if (__recsize) \
708                 __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \
709         else \
710                 __kfifo->in += __len / sizeof(*__tmp->type); \
711 })
712
713 /**
714  * kfifo_dma_out_prepare - setup a scatterlist for DMA output
715  * @fifo: address of the fifo to be used
716  * @sgl: pointer to the scatterlist array
717  * @nents: number of entries in the scatterlist array
718  * @len: number of elements to transfer
719  *
720  * This macro fills a scatterlist for DMA output which at most @len bytes
721  * to transfer.
722  * It returns the number entries in the scatterlist array.
723  * A zero means there is no space available and the scatterlist is not filled.
724  *
725  * Note that with only one concurrent reader and one concurrent
726  * writer, you don't need extra locking to use these macros.
727  */
728 #define kfifo_dma_out_prepare(fifo, sgl, nents, len) \
729 ({ \
730         typeof((fifo) + 1) __tmp = (fifo);  \
731         struct scatterlist *__sgl = (sgl); \
732         int __nents = (nents); \
733         unsigned int __len = (len); \
734         const size_t __recsize = sizeof(*__tmp->rectype); \
735         struct __kfifo *__kfifo = &__tmp->kfifo; \
736         (__recsize) ? \
737         __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
738         __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \
739 })
740
741 /**
742  * kfifo_dma_out_finish - finish a DMA OUT operation
743  * @fifo: address of the fifo to be used
744  * @len: number of bytes transferd
745  *
746  * This macro finish a DMA OUT operation. The out counter will be updated by
747  * the len parameter. No error checking will be done.
748  *
749  * Note that with only one concurrent reader and one concurrent
750  * writer, you don't need extra locking to use these macros.
751  */
752 #define kfifo_dma_out_finish(fifo, len) \
753 (void)({ \
754         typeof((fifo) + 1) __tmp = (fifo); \
755         unsigned int __len = (len); \
756         const size_t __recsize = sizeof(*__tmp->rectype); \
757         struct __kfifo *__kfifo = &__tmp->kfifo; \
758         if (__recsize) \
759                 __kfifo_dma_out_finish_r(__kfifo, __recsize); \
760         else \
761                 __kfifo->out += __len / sizeof(*__tmp->type); \
762 })
763
764 /**
765  * kfifo_out_peek - gets some data from the fifo
766  * @fifo: address of the fifo to be used
767  * @buf: pointer to the storage buffer
768  * @n: max. number of elements to get
769  *
770  * This macro get the data from the fifo and return the numbers of elements
771  * copied. The data is not removed from the fifo.
772  *
773  * Note that with only one concurrent reader and one concurrent
774  * writer, you don't need extra locking to use these macro.
775  */
776 #define kfifo_out_peek(fifo, buf, n) \
777 __kfifo_uint_must_check_helper( \
778 ({ \
779         typeof((fifo) + 1) __tmp = (fifo); \
780         typeof((buf) + 1) __buf = (buf); \
781         unsigned long __n = (n); \
782         const size_t __recsize = sizeof(*__tmp->rectype); \
783         struct __kfifo *__kfifo = &__tmp->kfifo; \
784         if (0) { \
785                 typeof(__tmp->ptr) __dummy __attribute__ ((unused)) = NULL; \
786                 __buf = __dummy; \
787         } \
788         (__recsize) ? \
789         __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \
790         __kfifo_out_peek(__kfifo, __buf, __n); \
791 }) \
792 )
793
794 extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size,
795         size_t esize, gfp_t gfp_mask);
796
797 extern void __kfifo_free(struct __kfifo *fifo);
798
799 extern int __kfifo_init(struct __kfifo *fifo, void *buffer,
800         unsigned int size, size_t esize);
801
802 extern unsigned int __kfifo_in(struct __kfifo *fifo,
803         const void *buf, unsigned int len);
804
805 extern unsigned int __kfifo_out(struct __kfifo *fifo,
806         void *buf, unsigned int len);
807
808 extern int __kfifo_from_user(struct __kfifo *fifo,
809         const void __user *from, unsigned long len, unsigned int *copied);
810
811 extern int __kfifo_to_user(struct __kfifo *fifo,
812         void __user *to, unsigned long len, unsigned int *copied);
813
814 extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
815         struct scatterlist *sgl, int nents, unsigned int len);
816
817 extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
818         struct scatterlist *sgl, int nents, unsigned int len);
819
820 extern unsigned int __kfifo_out_peek(struct __kfifo *fifo,
821         void *buf, unsigned int len);
822
823 extern unsigned int __kfifo_in_r(struct __kfifo *fifo,
824         const void *buf, unsigned int len, size_t recsize);
825
826 extern unsigned int __kfifo_out_r(struct __kfifo *fifo,
827         void *buf, unsigned int len, size_t recsize);
828
829 extern int __kfifo_from_user_r(struct __kfifo *fifo,
830         const void __user *from, unsigned long len, unsigned int *copied,
831         size_t recsize);
832
833 extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
834         unsigned long len, unsigned int *copied, size_t recsize);
835
836 extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
837         struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
838
839 extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
840         unsigned int len, size_t recsize);
841
842 extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
843         struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
844
845 extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize);
846
847 extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize);
848
849 extern void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize);
850
851 extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo,
852         void *buf, unsigned int len, size_t recsize);
853
854 extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize);
855
856 #endif
857 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) */