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