3 * Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sound/core.h>
23 #include <linux/slab.h>
31 struct snd_seq_fifo *snd_seq_fifo_new(int poolsize)
33 struct snd_seq_fifo *f;
35 f = kzalloc(sizeof(*f), GFP_KERNEL);
39 f->pool = snd_seq_pool_new(poolsize);
40 if (f->pool == NULL) {
44 if (snd_seq_pool_init(f->pool) < 0) {
45 snd_seq_pool_delete(&f->pool);
50 spin_lock_init(&f->lock);
51 snd_use_lock_init(&f->use_lock);
52 init_waitqueue_head(&f->input_sleep);
53 atomic_set(&f->overflow, 0);
62 void snd_seq_fifo_delete(struct snd_seq_fifo **fifo)
64 struct snd_seq_fifo *f;
66 if (snd_BUG_ON(!fifo))
74 snd_seq_pool_mark_closing(f->pool);
76 snd_seq_fifo_clear(f);
78 /* wake up clients if any */
79 if (waitqueue_active(&f->input_sleep))
80 wake_up(&f->input_sleep);
82 /* release resources...*/
83 /*....................*/
86 snd_seq_pool_done(f->pool);
87 snd_seq_pool_delete(&f->pool);
93 static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f);
96 void snd_seq_fifo_clear(struct snd_seq_fifo *f)
98 struct snd_seq_event_cell *cell;
101 /* clear overflow flag */
102 atomic_set(&f->overflow, 0);
104 snd_use_lock_sync(&f->use_lock);
105 spin_lock_irqsave(&f->lock, flags);
107 while ((cell = fifo_cell_out(f)) != NULL) {
108 snd_seq_cell_free(cell);
110 spin_unlock_irqrestore(&f->lock, flags);
114 /* enqueue event to fifo */
115 int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
116 struct snd_seq_event *event)
118 struct snd_seq_event_cell *cell;
125 snd_use_lock_use(&f->use_lock);
126 err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL, NULL); /* always non-blocking */
128 if ((err == -ENOMEM) || (err == -EAGAIN))
129 atomic_inc(&f->overflow);
130 snd_use_lock_free(&f->use_lock);
134 /* append new cells to fifo */
135 spin_lock_irqsave(&f->lock, flags);
137 f->tail->next = cell;
143 spin_unlock_irqrestore(&f->lock, flags);
146 if (waitqueue_active(&f->input_sleep))
147 wake_up(&f->input_sleep);
149 snd_use_lock_free(&f->use_lock);
151 return 0; /* success */
155 /* dequeue cell from fifo */
156 static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f)
158 struct snd_seq_event_cell *cell;
160 if ((cell = f->head) != NULL) {
161 f->head = cell->next;
163 /* reset tail if this was the last element */
174 /* dequeue cell from fifo and copy on user space */
175 int snd_seq_fifo_cell_out(struct snd_seq_fifo *f,
176 struct snd_seq_event_cell **cellp, int nonblock)
178 struct snd_seq_event_cell *cell;
186 init_waitqueue_entry(&wait, current);
187 spin_lock_irqsave(&f->lock, flags);
188 while ((cell = fifo_cell_out(f)) == NULL) {
190 /* non-blocking - return immediately */
191 spin_unlock_irqrestore(&f->lock, flags);
194 set_current_state(TASK_INTERRUPTIBLE);
195 add_wait_queue(&f->input_sleep, &wait);
196 spin_unlock_irq(&f->lock);
198 spin_lock_irq(&f->lock);
199 remove_wait_queue(&f->input_sleep, &wait);
200 if (signal_pending(current)) {
201 spin_unlock_irqrestore(&f->lock, flags);
205 spin_unlock_irqrestore(&f->lock, flags);
212 void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f,
213 struct snd_seq_event_cell *cell)
218 spin_lock_irqsave(&f->lock, flags);
219 cell->next = f->head;
224 spin_unlock_irqrestore(&f->lock, flags);
229 /* polling; return non-zero if queue is available */
230 int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file,
233 poll_wait(file, &f->input_sleep, wait);
234 return (f->cells > 0);
237 /* change the size of pool; all old events are removed */
238 int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
241 struct snd_seq_pool *newpool, *oldpool;
242 struct snd_seq_event_cell *cell, *next, *oldhead;
244 if (snd_BUG_ON(!f || !f->pool))
247 /* allocate new pool */
248 newpool = snd_seq_pool_new(poolsize);
251 if (snd_seq_pool_init(newpool) < 0) {
252 snd_seq_pool_delete(&newpool);
256 spin_lock_irqsave(&f->lock, flags);
257 /* remember old pool */
265 /* NOTE: overflow flag is not cleared */
266 spin_unlock_irqrestore(&f->lock, flags);
268 /* close the old pool and wait until all users are gone */
269 snd_seq_pool_mark_closing(oldpool);
270 snd_use_lock_sync(&f->use_lock);
272 /* release cells in old pool */
273 for (cell = oldhead; cell; cell = next) {
275 snd_seq_cell_free(cell);
277 snd_seq_pool_delete(&oldpool);
282 /* get the number of unused cells safely */
283 int snd_seq_fifo_unused_cells(struct snd_seq_fifo *f)
291 snd_use_lock_use(&f->use_lock);
292 spin_lock_irqsave(&f->lock, flags);
293 cells = snd_seq_unused_cells(f->pool);
294 spin_unlock_irqrestore(&f->lock, flags);
295 snd_use_lock_free(&f->use_lock);