2 * A generic kernel FIFO implementation.
4 * Copyright (C) 2009 Stefani Seibold <stefani@seibold.net>
5 * Copyright (C) 2004 Stelian Pop <stelian@popies.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * Howto porting drivers to the new generic fifo API:
26 * - Modify the declaration of the "struct kfifo *" object into a
27 * in-place "struct kfifo" object
28 * - Init the in-place object with kfifo_alloc() or kfifo_init()
29 * Note: The address of the in-place "struct kfifo" object must be
30 * passed as the first argument to this functions
31 * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
33 * - Replace the use of kfifo_put into kfifo_in_locked and kfifo_get
34 * into kfifo_out_locked
35 * Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
36 * must be passed now to the kfifo_in_locked and kfifo_out_locked
37 * as the last parameter.
38 * - All formerly name __kfifo_* functions has been renamed into kfifo_*
41 #ifndef _LINUX_KFIFO_H
42 #define _LINUX_KFIFO_H
44 #include <linux/kernel.h>
45 #include <linux/spinlock.h>
48 unsigned char *buffer
; /* the buffer holding the data */
49 unsigned int size
; /* the size of the allocated buffer */
50 unsigned int in
; /* data is added at offset (in % size) */
51 unsigned int out
; /* data is extracted from off. (out % size) */
55 * Macros for declaration and initialization of the kfifo datatype
59 #define __kfifo_initializer(s, b) \
68 * DECLARE_KFIFO - macro to declare a kfifo and the associated buffer
69 * @name: name of the declared kfifo datatype
70 * @size: size of the fifo buffer. Must be a power of two.
72 * Note1: the macro can be used inside struct or union declaration
73 * Note2: the macro creates two objects:
74 * A kfifo object with the given name and a buffer for the kfifo
75 * object named name##kfifo_buffer
77 #define DECLARE_KFIFO(name, size) \
80 unsigned char name##kfifo_buffer[size + sizeof(struct kfifo)]; \
84 * INIT_KFIFO - Initialize a kfifo declared by DECLARE_KFIFO
85 * @name: name of the declared kfifo datatype
87 #define INIT_KFIFO(name) \
88 name = __kfifo_initializer(sizeof(name##kfifo_buffer) - \
89 sizeof(struct kfifo), name##kfifo_buffer)
92 * DEFINE_KFIFO - macro to define and initialize a kfifo
93 * @name: name of the declared kfifo datatype
94 * @size: size of the fifo buffer. Must be a power of two.
96 * Note1: the macro can be used for global and local kfifo data type variables
97 * Note2: the macro creates two objects:
98 * A kfifo object with the given name and a buffer for the kfifo
99 * object named name##kfifo_buffer
101 #define DEFINE_KFIFO(name, size) \
102 unsigned char name##kfifo_buffer[size]; \
103 struct kfifo name = __kfifo_initializer(size, name##kfifo_buffer)
105 extern void kfifo_init(struct kfifo
*fifo
, void *buffer
,
107 extern __must_check
int kfifo_alloc(struct kfifo
*fifo
, unsigned int size
,
109 extern void kfifo_free(struct kfifo
*fifo
);
110 extern unsigned int kfifo_in(struct kfifo
*fifo
,
111 const void *from
, unsigned int len
);
112 extern __must_check
unsigned int kfifo_out(struct kfifo
*fifo
,
113 void *to
, unsigned int len
);
114 extern __must_check
unsigned int kfifo_out_peek(struct kfifo
*fifo
,
115 void *to
, unsigned int len
, unsigned offset
);
118 * kfifo_initialized - Check if kfifo is initialized.
119 * @fifo: fifo to check
120 * Return %true if FIFO is initialized, otherwise %false.
121 * Assumes the fifo was 0 before.
123 static inline bool kfifo_initialized(struct kfifo
*fifo
)
125 return fifo
->buffer
!= NULL
;
129 * kfifo_reset - removes the entire FIFO contents
130 * @fifo: the fifo to be emptied.
132 static inline void kfifo_reset(struct kfifo
*fifo
)
134 fifo
->in
= fifo
->out
= 0;
138 * kfifo_reset_out - skip FIFO contents
139 * @fifo: the fifo to be emptied.
141 static inline void kfifo_reset_out(struct kfifo
*fifo
)
144 fifo
->out
= fifo
->in
;
148 * kfifo_size - returns the size of the fifo in bytes
149 * @fifo: the fifo to be used.
151 static inline __must_check
unsigned int kfifo_size(struct kfifo
*fifo
)
157 * kfifo_len - returns the number of used bytes in the FIFO
158 * @fifo: the fifo to be used.
160 static inline unsigned int kfifo_len(struct kfifo
*fifo
)
162 register unsigned int out
;
166 return fifo
->in
- out
;
170 * kfifo_is_empty - returns true if the fifo is empty
171 * @fifo: the fifo to be used.
173 static inline __must_check
int kfifo_is_empty(struct kfifo
*fifo
)
175 return fifo
->in
== fifo
->out
;
179 * kfifo_is_full - returns true if the fifo is full
180 * @fifo: the fifo to be used.
182 static inline __must_check
int kfifo_is_full(struct kfifo
*fifo
)
184 return kfifo_len(fifo
) == kfifo_size(fifo
);
188 * kfifo_avail - returns the number of bytes available in the FIFO
189 * @fifo: the fifo to be used.
191 static inline __must_check
unsigned int kfifo_avail(struct kfifo
*fifo
)
193 return kfifo_size(fifo
) - kfifo_len(fifo
);
197 * kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
198 * @fifo: the fifo to be used.
199 * @from: the data to be added.
200 * @n: the length of the data to be added.
201 * @lock: pointer to the spinlock to use for locking.
203 * This function copies at most @len bytes from the @from buffer into
204 * the FIFO depending on the free space, and returns the number of
207 static inline unsigned int kfifo_in_locked(struct kfifo
*fifo
,
208 const void *from
, unsigned int n
, spinlock_t
*lock
)
213 spin_lock_irqsave(lock
, flags
);
215 ret
= kfifo_in(fifo
, from
, n
);
217 spin_unlock_irqrestore(lock
, flags
);
223 * kfifo_out_locked - gets some data from the FIFO using a spinlock for locking
224 * @fifo: the fifo to be used.
225 * @to: where the data must be copied.
226 * @n: the size of the destination buffer.
227 * @lock: pointer to the spinlock to use for locking.
229 * This function copies at most @len bytes from the FIFO into the
230 * @to buffer and returns the number of copied bytes.
232 static inline __must_check
unsigned int kfifo_out_locked(struct kfifo
*fifo
,
233 void *to
, unsigned int n
, spinlock_t
*lock
)
238 spin_lock_irqsave(lock
, flags
);
240 ret
= kfifo_out(fifo
, to
, n
);
242 spin_unlock_irqrestore(lock
, flags
);
247 extern void kfifo_skip(struct kfifo
*fifo
, unsigned int len
);
249 extern __must_check
int kfifo_from_user(struct kfifo
*fifo
,
250 const void __user
*from
, unsigned int n
, unsigned *lenout
);
252 extern __must_check
int kfifo_to_user(struct kfifo
*fifo
,
253 void __user
*to
, unsigned int n
, unsigned *lenout
);
256 * __kfifo_add_out internal helper function for updating the out offset
258 static inline void __kfifo_add_out(struct kfifo
*fifo
,
266 * __kfifo_add_in internal helper function for updating the in offset
268 static inline void __kfifo_add_in(struct kfifo
*fifo
,
276 * __kfifo_off internal helper function for calculating the index of a
279 static inline unsigned int __kfifo_off(struct kfifo
*fifo
, unsigned int off
)
281 return off
& (fifo
->size
- 1);
285 * __kfifo_peek_n internal helper function for determinate the length of
286 * the next record in the fifo
288 static inline unsigned int __kfifo_peek_n(struct kfifo
*fifo
,
289 unsigned int recsize
)
291 #define __KFIFO_GET(fifo, off, shift) \
292 ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
296 l
= __KFIFO_GET(fifo
, 0, 0);
299 l
|= __KFIFO_GET(fifo
, 1, 8);
306 * __kfifo_poke_n internal helper function for storing the length of
307 * the next record into the fifo
309 static inline void __kfifo_poke_n(struct kfifo
*fifo
,
310 unsigned int recsize
, unsigned int n
)
312 #define __KFIFO_PUT(fifo, off, val, shift) \
314 (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
315 (unsigned char)((val) >> (shift)) \
318 __KFIFO_PUT(fifo
, 0, n
, 0);
321 __KFIFO_PUT(fifo
, 1, n
, 8);
326 * __kfifo_in_... internal functions for put date into the fifo
327 * do not call it directly, use kfifo_in_rec() instead
329 extern unsigned int __kfifo_in_n(struct kfifo
*fifo
,
330 const void *from
, unsigned int n
, unsigned int recsize
);
332 extern unsigned int __kfifo_in_generic(struct kfifo
*fifo
,
333 const void *from
, unsigned int n
, unsigned int recsize
);
335 static inline unsigned int __kfifo_in_rec(struct kfifo
*fifo
,
336 const void *from
, unsigned int n
, unsigned int recsize
)
340 ret
= __kfifo_in_n(fifo
, from
, n
, recsize
);
342 if (likely(ret
== 0)) {
344 __kfifo_poke_n(fifo
, recsize
, n
);
345 __kfifo_add_in(fifo
, n
+ recsize
);
351 * kfifo_in_rec - puts some record data into the FIFO
352 * @fifo: the fifo to be used.
353 * @from: the data to be added.
354 * @n: the length of the data to be added.
355 * @recsize: size of record field
357 * This function copies @n bytes from the @from into the FIFO and returns
358 * the number of bytes which cannot be copied.
359 * A returned value greater than the @n value means that the record doesn't
360 * fit into the buffer.
362 * Note that with only one concurrent reader and one concurrent
363 * writer, you don't need extra locking to use these functions.
365 static inline __must_check
unsigned int kfifo_in_rec(struct kfifo
*fifo
,
366 void *from
, unsigned int n
, unsigned int recsize
)
368 if (!__builtin_constant_p(recsize
))
369 return __kfifo_in_generic(fifo
, from
, n
, recsize
);
370 return __kfifo_in_rec(fifo
, from
, n
, recsize
);
374 * __kfifo_out_... internal functions for get date from the fifo
375 * do not call it directly, use kfifo_out_rec() instead
377 extern unsigned int __kfifo_out_n(struct kfifo
*fifo
,
378 void *to
, unsigned int reclen
, unsigned int recsize
);
380 extern unsigned int __kfifo_out_generic(struct kfifo
*fifo
,
381 void *to
, unsigned int n
,
382 unsigned int recsize
, unsigned int *total
);
384 static inline unsigned int __kfifo_out_rec(struct kfifo
*fifo
,
385 void *to
, unsigned int n
, unsigned int recsize
,
395 l
= __kfifo_peek_n(fifo
, recsize
);
402 return __kfifo_out_n(fifo
, to
, l
, recsize
);
406 * kfifo_out_rec - gets some record data from the FIFO
407 * @fifo: the fifo to be used.
408 * @to: where the data must be copied.
409 * @n: the size of the destination buffer.
410 * @recsize: size of record field
411 * @total: pointer where the total number of to copied bytes should stored
413 * This function copies at most @n bytes from the FIFO to @to and returns the
414 * number of bytes which cannot be copied.
415 * A returned value greater than the @n value means that the record doesn't
416 * fit into the @to buffer.
418 * Note that with only one concurrent reader and one concurrent
419 * writer, you don't need extra locking to use these functions.
421 static inline __must_check
unsigned int kfifo_out_rec(struct kfifo
*fifo
,
422 void *to
, unsigned int n
, unsigned int recsize
,
426 if (!__builtin_constant_p(recsize
))
427 return __kfifo_out_generic(fifo
, to
, n
, recsize
, total
);
428 return __kfifo_out_rec(fifo
, to
, n
, recsize
, total
);
432 * __kfifo_from_user_... internal functions for transfer from user space into
433 * the fifo. do not call it directly, use kfifo_from_user_rec() instead
435 extern unsigned int __kfifo_from_user_n(struct kfifo
*fifo
,
436 const void __user
*from
, unsigned int n
, unsigned int recsize
);
438 extern unsigned int __kfifo_from_user_generic(struct kfifo
*fifo
,
439 const void __user
*from
, unsigned int n
, unsigned int recsize
);
441 static inline unsigned int __kfifo_from_user_rec(struct kfifo
*fifo
,
442 const void __user
*from
, unsigned int n
, unsigned int recsize
)
446 ret
= __kfifo_from_user_n(fifo
, from
, n
, recsize
);
448 if (likely(ret
== 0)) {
450 __kfifo_poke_n(fifo
, recsize
, n
);
451 __kfifo_add_in(fifo
, n
+ recsize
);
457 * kfifo_from_user_rec - puts some data from user space into the FIFO
458 * @fifo: the fifo to be used.
459 * @from: pointer to the data to be added.
460 * @n: the length of the data to be added.
461 * @recsize: size of record field
463 * This function copies @n bytes from the @from into the
464 * FIFO and returns the number of bytes which cannot be copied.
466 * If the returned value is equal or less the @n value, the copy_from_user()
467 * functions has failed. Otherwise the record doesn't fit into the buffer.
469 * Note that with only one concurrent reader and one concurrent
470 * writer, you don't need extra locking to use these functions.
472 static inline __must_check
unsigned int kfifo_from_user_rec(struct kfifo
*fifo
,
473 const void __user
*from
, unsigned int n
, unsigned int recsize
)
475 if (!__builtin_constant_p(recsize
))
476 return __kfifo_from_user_generic(fifo
, from
, n
, recsize
);
477 return __kfifo_from_user_rec(fifo
, from
, n
, recsize
);
481 * __kfifo_to_user_... internal functions for transfer fifo data into user space
482 * do not call it directly, use kfifo_to_user_rec() instead
484 extern unsigned int __kfifo_to_user_n(struct kfifo
*fifo
,
485 void __user
*to
, unsigned int n
, unsigned int reclen
,
486 unsigned int recsize
);
488 extern unsigned int __kfifo_to_user_generic(struct kfifo
*fifo
,
489 void __user
*to
, unsigned int n
, unsigned int recsize
,
490 unsigned int *total
);
492 static inline unsigned int __kfifo_to_user_rec(struct kfifo
*fifo
,
493 void __user
*to
, unsigned int n
,
494 unsigned int recsize
, unsigned int *total
)
503 l
= __kfifo_peek_n(fifo
, recsize
);
510 return __kfifo_to_user_n(fifo
, to
, n
, l
, recsize
);
514 * kfifo_to_user_rec - gets data from the FIFO and write it to user space
515 * @fifo: the fifo to be used.
516 * @to: where the data must be copied.
517 * @n: the size of the destination buffer.
518 * @recsize: size of record field
519 * @total: pointer where the total number of to copied bytes should stored
521 * This function copies at most @n bytes from the FIFO to the @to.
522 * In case of an error, the function returns the number of bytes which cannot
524 * If the returned value is equal or less the @n value, the copy_to_user()
525 * functions has failed. Otherwise the record doesn't fit into the @to buffer.
527 * Note that with only one concurrent reader and one concurrent
528 * writer, you don't need extra locking to use these functions.
530 static inline __must_check
unsigned int kfifo_to_user_rec(struct kfifo
*fifo
,
531 void __user
*to
, unsigned int n
, unsigned int recsize
,
534 if (!__builtin_constant_p(recsize
))
535 return __kfifo_to_user_generic(fifo
, to
, n
, recsize
, total
);
536 return __kfifo_to_user_rec(fifo
, to
, n
, recsize
, total
);
540 * __kfifo_peek_... internal functions for peek into the next fifo record
541 * do not call it directly, use kfifo_peek_rec() instead
543 extern unsigned int __kfifo_peek_generic(struct kfifo
*fifo
,
544 unsigned int recsize
);
547 * kfifo_peek_rec - gets the size of the next FIFO record data
548 * @fifo: the fifo to be used.
549 * @recsize: size of record field
551 * This function returns the size of the next FIFO record in number of bytes
553 static inline __must_check
unsigned int kfifo_peek_rec(struct kfifo
*fifo
,
554 unsigned int recsize
)
556 if (!__builtin_constant_p(recsize
))
557 return __kfifo_peek_generic(fifo
, recsize
);
559 return kfifo_len(fifo
);
560 return __kfifo_peek_n(fifo
, recsize
);
564 * __kfifo_skip_... internal functions for skip the next fifo record
565 * do not call it directly, use kfifo_skip_rec() instead
567 extern void __kfifo_skip_generic(struct kfifo
*fifo
, unsigned int recsize
);
569 static inline void __kfifo_skip_rec(struct kfifo
*fifo
,
570 unsigned int recsize
)
575 l
= __kfifo_peek_n(fifo
, recsize
);
577 if (l
+ recsize
<= kfifo_len(fifo
)) {
578 __kfifo_add_out(fifo
, l
+ recsize
);
582 kfifo_reset_out(fifo
);
586 * kfifo_skip_rec - skip the next fifo out record
587 * @fifo: the fifo to be used.
588 * @recsize: size of record field
590 * This function skips the next FIFO record
592 static inline void kfifo_skip_rec(struct kfifo
*fifo
,
593 unsigned int recsize
)
595 if (!__builtin_constant_p(recsize
))
596 __kfifo_skip_generic(fifo
, recsize
);
598 __kfifo_skip_rec(fifo
, recsize
);
602 * kfifo_avail_rec - returns the number of bytes available in a record FIFO
603 * @fifo: the fifo to be used.
604 * @recsize: size of record field
606 static inline __must_check
unsigned int kfifo_avail_rec(struct kfifo
*fifo
,
607 unsigned int recsize
)
609 unsigned int l
= kfifo_size(fifo
) - kfifo_len(fifo
);
611 return (l
> recsize
) ? l
- recsize
: 0;