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), \
90 name##kfifo_buffer + sizeof(struct kfifo))
93 * DEFINE_KFIFO - macro to define and initialize a kfifo
94 * @name: name of the declared kfifo datatype
95 * @size: size of the fifo buffer. Must be a power of two.
97 * Note1: the macro can be used for global and local kfifo data type variables
98 * Note2: the macro creates two objects:
99 * A kfifo object with the given name and a buffer for the kfifo
100 * object named name##kfifo_buffer
102 #define DEFINE_KFIFO(name, size) \
103 unsigned char name##kfifo_buffer[size]; \
104 struct kfifo name = __kfifo_initializer(size, name##kfifo_buffer)
106 extern void kfifo_init(struct kfifo
*fifo
, void *buffer
,
108 extern __must_check
int kfifo_alloc(struct kfifo
*fifo
, unsigned int size
,
110 extern void kfifo_free(struct kfifo
*fifo
);
111 extern unsigned int kfifo_in(struct kfifo
*fifo
,
112 const void *from
, unsigned int len
);
113 extern __must_check
unsigned int kfifo_out(struct kfifo
*fifo
,
114 void *to
, unsigned int len
);
115 extern __must_check
unsigned int kfifo_out_peek(struct kfifo
*fifo
,
116 void *to
, unsigned int len
, unsigned offset
);
119 * kfifo_initialized - Check if kfifo is initialized.
120 * @fifo: fifo to check
121 * Return %true if FIFO is initialized, otherwise %false.
122 * Assumes the fifo was 0 before.
124 static inline bool kfifo_initialized(struct kfifo
*fifo
)
126 return fifo
->buffer
!= NULL
;
130 * kfifo_reset - removes the entire FIFO contents
131 * @fifo: the fifo to be emptied.
133 static inline void kfifo_reset(struct kfifo
*fifo
)
135 fifo
->in
= fifo
->out
= 0;
139 * kfifo_reset_out - skip FIFO contents
140 * @fifo: the fifo to be emptied.
142 static inline void kfifo_reset_out(struct kfifo
*fifo
)
145 fifo
->out
= fifo
->in
;
149 * kfifo_size - returns the size of the fifo in bytes
150 * @fifo: the fifo to be used.
152 static inline __must_check
unsigned int kfifo_size(struct kfifo
*fifo
)
158 * kfifo_len - returns the number of used bytes in the FIFO
159 * @fifo: the fifo to be used.
161 static inline unsigned int kfifo_len(struct kfifo
*fifo
)
163 register unsigned int out
;
167 return fifo
->in
- out
;
171 * kfifo_is_empty - returns true if the fifo is empty
172 * @fifo: the fifo to be used.
174 static inline __must_check
int kfifo_is_empty(struct kfifo
*fifo
)
176 return fifo
->in
== fifo
->out
;
180 * kfifo_is_full - returns true if the fifo is full
181 * @fifo: the fifo to be used.
183 static inline __must_check
int kfifo_is_full(struct kfifo
*fifo
)
185 return kfifo_len(fifo
) == kfifo_size(fifo
);
189 * kfifo_avail - returns the number of bytes available in the FIFO
190 * @fifo: the fifo to be used.
192 static inline __must_check
unsigned int kfifo_avail(struct kfifo
*fifo
)
194 return kfifo_size(fifo
) - kfifo_len(fifo
);
198 * kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
199 * @fifo: the fifo to be used.
200 * @from: the data to be added.
201 * @n: the length of the data to be added.
202 * @lock: pointer to the spinlock to use for locking.
204 * This function copies at most @n bytes from the @from buffer into
205 * the FIFO depending on the free space, and returns the number of
208 static inline unsigned int kfifo_in_locked(struct kfifo
*fifo
,
209 const void *from
, unsigned int n
, spinlock_t
*lock
)
214 spin_lock_irqsave(lock
, flags
);
216 ret
= kfifo_in(fifo
, from
, n
);
218 spin_unlock_irqrestore(lock
, flags
);
224 * kfifo_out_locked - gets some data from the FIFO using a spinlock for locking
225 * @fifo: the fifo to be used.
226 * @to: where the data must be copied.
227 * @n: the size of the destination buffer.
228 * @lock: pointer to the spinlock to use for locking.
230 * This function copies at most @n bytes from the FIFO into the
231 * @to buffer and returns the number of copied bytes.
233 static inline __must_check
unsigned int kfifo_out_locked(struct kfifo
*fifo
,
234 void *to
, unsigned int n
, spinlock_t
*lock
)
239 spin_lock_irqsave(lock
, flags
);
241 ret
= kfifo_out(fifo
, to
, n
);
243 spin_unlock_irqrestore(lock
, flags
);
248 extern void kfifo_skip(struct kfifo
*fifo
, unsigned int len
);
250 extern __must_check
int kfifo_from_user(struct kfifo
*fifo
,
251 const void __user
*from
, unsigned int n
, unsigned *lenout
);
253 extern __must_check
int kfifo_to_user(struct kfifo
*fifo
,
254 void __user
*to
, unsigned int n
, unsigned *lenout
);
257 * __kfifo_add_out internal helper function for updating the out offset
259 static inline void __kfifo_add_out(struct kfifo
*fifo
,
267 * __kfifo_add_in internal helper function for updating the in offset
269 static inline void __kfifo_add_in(struct kfifo
*fifo
,
277 * __kfifo_off internal helper function for calculating the index of a
280 static inline unsigned int __kfifo_off(struct kfifo
*fifo
, unsigned int off
)
282 return off
& (fifo
->size
- 1);
286 * __kfifo_peek_n internal helper function for determinate the length of
287 * the next record in the fifo
289 static inline unsigned int __kfifo_peek_n(struct kfifo
*fifo
,
290 unsigned int recsize
)
292 #define __KFIFO_GET(fifo, off, shift) \
293 ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
297 l
= __KFIFO_GET(fifo
, 0, 0);
300 l
|= __KFIFO_GET(fifo
, 1, 8);
307 * __kfifo_poke_n internal helper function for storing the length of
308 * the next record into the fifo
310 static inline void __kfifo_poke_n(struct kfifo
*fifo
,
311 unsigned int recsize
, unsigned int n
)
313 #define __KFIFO_PUT(fifo, off, val, shift) \
315 (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
316 (unsigned char)((val) >> (shift)) \
319 __KFIFO_PUT(fifo
, 0, n
, 0);
322 __KFIFO_PUT(fifo
, 1, n
, 8);
327 * __kfifo_in_... internal functions for put date into the fifo
328 * do not call it directly, use kfifo_in_rec() instead
330 extern unsigned int __kfifo_in_n(struct kfifo
*fifo
,
331 const void *from
, unsigned int n
, unsigned int recsize
);
333 extern unsigned int __kfifo_in_generic(struct kfifo
*fifo
,
334 const void *from
, unsigned int n
, unsigned int recsize
);
336 static inline unsigned int __kfifo_in_rec(struct kfifo
*fifo
,
337 const void *from
, unsigned int n
, unsigned int recsize
)
341 ret
= __kfifo_in_n(fifo
, from
, n
, recsize
);
343 if (likely(ret
== 0)) {
345 __kfifo_poke_n(fifo
, recsize
, n
);
346 __kfifo_add_in(fifo
, n
+ recsize
);
352 * kfifo_in_rec - puts some record data into the FIFO
353 * @fifo: the fifo to be used.
354 * @from: the data to be added.
355 * @n: the length of the data to be added.
356 * @recsize: size of record field
358 * This function copies @n bytes from the @from into the FIFO and returns
359 * the number of bytes which cannot be copied.
360 * A returned value greater than the @n value means that the record doesn't
361 * fit into the buffer.
363 * Note that with only one concurrent reader and one concurrent
364 * writer, you don't need extra locking to use these functions.
366 static inline __must_check
unsigned int kfifo_in_rec(struct kfifo
*fifo
,
367 void *from
, unsigned int n
, unsigned int recsize
)
369 if (!__builtin_constant_p(recsize
))
370 return __kfifo_in_generic(fifo
, from
, n
, recsize
);
371 return __kfifo_in_rec(fifo
, from
, n
, recsize
);
375 * __kfifo_out_... internal functions for get date from the fifo
376 * do not call it directly, use kfifo_out_rec() instead
378 extern unsigned int __kfifo_out_n(struct kfifo
*fifo
,
379 void *to
, unsigned int reclen
, unsigned int recsize
);
381 extern unsigned int __kfifo_out_generic(struct kfifo
*fifo
,
382 void *to
, unsigned int n
,
383 unsigned int recsize
, unsigned int *total
);
385 static inline unsigned int __kfifo_out_rec(struct kfifo
*fifo
,
386 void *to
, unsigned int n
, unsigned int recsize
,
396 l
= __kfifo_peek_n(fifo
, recsize
);
403 return __kfifo_out_n(fifo
, to
, l
, recsize
);
407 * kfifo_out_rec - gets some record data from the FIFO
408 * @fifo: the fifo to be used.
409 * @to: where the data must be copied.
410 * @n: the size of the destination buffer.
411 * @recsize: size of record field
412 * @total: pointer where the total number of to copied bytes should stored
414 * This function copies at most @n bytes from the FIFO to @to and returns the
415 * number of bytes which cannot be copied.
416 * A returned value greater than the @n value means that the record doesn't
417 * fit into the @to buffer.
419 * Note that with only one concurrent reader and one concurrent
420 * writer, you don't need extra locking to use these functions.
422 static inline __must_check
unsigned int kfifo_out_rec(struct kfifo
*fifo
,
423 void *to
, unsigned int n
, unsigned int recsize
,
427 if (!__builtin_constant_p(recsize
))
428 return __kfifo_out_generic(fifo
, to
, n
, recsize
, total
);
429 return __kfifo_out_rec(fifo
, to
, n
, recsize
, total
);
433 * __kfifo_from_user_... internal functions for transfer from user space into
434 * the fifo. do not call it directly, use kfifo_from_user_rec() instead
436 extern unsigned int __kfifo_from_user_n(struct kfifo
*fifo
,
437 const void __user
*from
, unsigned int n
, unsigned int recsize
);
439 extern unsigned int __kfifo_from_user_generic(struct kfifo
*fifo
,
440 const void __user
*from
, unsigned int n
, unsigned int recsize
);
442 static inline unsigned int __kfifo_from_user_rec(struct kfifo
*fifo
,
443 const void __user
*from
, unsigned int n
, unsigned int recsize
)
447 ret
= __kfifo_from_user_n(fifo
, from
, n
, recsize
);
449 if (likely(ret
== 0)) {
451 __kfifo_poke_n(fifo
, recsize
, n
);
452 __kfifo_add_in(fifo
, n
+ recsize
);
458 * kfifo_from_user_rec - puts some data from user space into the FIFO
459 * @fifo: the fifo to be used.
460 * @from: pointer to the data to be added.
461 * @n: the length of the data to be added.
462 * @recsize: size of record field
464 * This function copies @n bytes from the @from into the
465 * FIFO and returns the number of bytes which cannot be copied.
467 * If the returned value is equal or less the @n value, the copy_from_user()
468 * functions has failed. Otherwise the record doesn't fit into the buffer.
470 * Note that with only one concurrent reader and one concurrent
471 * writer, you don't need extra locking to use these functions.
473 static inline __must_check
unsigned int kfifo_from_user_rec(struct kfifo
*fifo
,
474 const void __user
*from
, unsigned int n
, unsigned int recsize
)
476 if (!__builtin_constant_p(recsize
))
477 return __kfifo_from_user_generic(fifo
, from
, n
, recsize
);
478 return __kfifo_from_user_rec(fifo
, from
, n
, recsize
);
482 * __kfifo_to_user_... internal functions for transfer fifo data into user space
483 * do not call it directly, use kfifo_to_user_rec() instead
485 extern unsigned int __kfifo_to_user_n(struct kfifo
*fifo
,
486 void __user
*to
, unsigned int n
, unsigned int reclen
,
487 unsigned int recsize
);
489 extern unsigned int __kfifo_to_user_generic(struct kfifo
*fifo
,
490 void __user
*to
, unsigned int n
, unsigned int recsize
,
491 unsigned int *total
);
493 static inline unsigned int __kfifo_to_user_rec(struct kfifo
*fifo
,
494 void __user
*to
, unsigned int n
,
495 unsigned int recsize
, unsigned int *total
)
504 l
= __kfifo_peek_n(fifo
, recsize
);
511 return __kfifo_to_user_n(fifo
, to
, n
, l
, recsize
);
515 * kfifo_to_user_rec - gets data from the FIFO and write it to user space
516 * @fifo: the fifo to be used.
517 * @to: where the data must be copied.
518 * @n: the size of the destination buffer.
519 * @recsize: size of record field
520 * @total: pointer where the total number of to copied bytes should stored
522 * This function copies at most @n bytes from the FIFO to the @to.
523 * In case of an error, the function returns the number of bytes which cannot
525 * If the returned value is equal or less the @n value, the copy_to_user()
526 * functions has failed. Otherwise the record doesn't fit into the @to buffer.
528 * Note that with only one concurrent reader and one concurrent
529 * writer, you don't need extra locking to use these functions.
531 static inline __must_check
unsigned int kfifo_to_user_rec(struct kfifo
*fifo
,
532 void __user
*to
, unsigned int n
, unsigned int recsize
,
535 if (!__builtin_constant_p(recsize
))
536 return __kfifo_to_user_generic(fifo
, to
, n
, recsize
, total
);
537 return __kfifo_to_user_rec(fifo
, to
, n
, recsize
, total
);
541 * __kfifo_peek_... internal functions for peek into the next fifo record
542 * do not call it directly, use kfifo_peek_rec() instead
544 extern unsigned int __kfifo_peek_generic(struct kfifo
*fifo
,
545 unsigned int recsize
);
548 * kfifo_peek_rec - gets the size of the next FIFO record data
549 * @fifo: the fifo to be used.
550 * @recsize: size of record field
552 * This function returns the size of the next FIFO record in number of bytes
554 static inline __must_check
unsigned int kfifo_peek_rec(struct kfifo
*fifo
,
555 unsigned int recsize
)
557 if (!__builtin_constant_p(recsize
))
558 return __kfifo_peek_generic(fifo
, recsize
);
560 return kfifo_len(fifo
);
561 return __kfifo_peek_n(fifo
, recsize
);
565 * __kfifo_skip_... internal functions for skip the next fifo record
566 * do not call it directly, use kfifo_skip_rec() instead
568 extern void __kfifo_skip_generic(struct kfifo
*fifo
, unsigned int recsize
);
570 static inline void __kfifo_skip_rec(struct kfifo
*fifo
,
571 unsigned int recsize
)
576 l
= __kfifo_peek_n(fifo
, recsize
);
578 if (l
+ recsize
<= kfifo_len(fifo
)) {
579 __kfifo_add_out(fifo
, l
+ recsize
);
583 kfifo_reset_out(fifo
);
587 * kfifo_skip_rec - skip the next fifo out record
588 * @fifo: the fifo to be used.
589 * @recsize: size of record field
591 * This function skips the next FIFO record
593 static inline void kfifo_skip_rec(struct kfifo
*fifo
,
594 unsigned int recsize
)
596 if (!__builtin_constant_p(recsize
))
597 __kfifo_skip_generic(fifo
, recsize
);
599 __kfifo_skip_rec(fifo
, recsize
);
603 * kfifo_avail_rec - returns the number of bytes available in a record FIFO
604 * @fifo: the fifo to be used.
605 * @recsize: size of record field
607 static inline __must_check
unsigned int kfifo_avail_rec(struct kfifo
*fifo
,
608 unsigned int recsize
)
610 unsigned int l
= kfifo_size(fifo
) - kfifo_len(fifo
);
612 return (l
> recsize
) ? l
- recsize
: 0;