1 /* 2 * ALSA sequencer FIFO 3 * Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl> 4 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 */ 21 22 #include <sound/core.h> 23 #include <linux/slab.h> 24 #include <linux/sched/signal.h> 25 26 #include "seq_fifo.h" 27 #include "seq_lock.h" 28 29 30 /* FIFO */ 31 32 /* create new fifo */ 33 struct snd_seq_fifo *snd_seq_fifo_new(int poolsize) 34 { 35 struct snd_seq_fifo *f; 36 37 f = kzalloc(sizeof(*f), GFP_KERNEL); 38 if (!f) 39 return NULL; 40 41 f->pool = snd_seq_pool_new(poolsize); 42 if (f->pool == NULL) { 43 kfree(f); 44 return NULL; 45 } 46 if (snd_seq_pool_init(f->pool) < 0) { 47 snd_seq_pool_delete(&f->pool); 48 kfree(f); 49 return NULL; 50 } 51 52 spin_lock_init(&f->lock); 53 snd_use_lock_init(&f->use_lock); 54 init_waitqueue_head(&f->input_sleep); 55 atomic_set(&f->overflow, 0); 56 57 f->head = NULL; 58 f->tail = NULL; 59 f->cells = 0; 60 61 return f; 62 } 63 64 void snd_seq_fifo_delete(struct snd_seq_fifo **fifo) 65 { 66 struct snd_seq_fifo *f; 67 68 if (snd_BUG_ON(!fifo)) 69 return; 70 f = *fifo; 71 if (snd_BUG_ON(!f)) 72 return; 73 *fifo = NULL; 74 75 snd_seq_fifo_clear(f); 76 77 /* wake up clients if any */ 78 if (waitqueue_active(&f->input_sleep)) 79 wake_up(&f->input_sleep); 80 81 /* release resources...*/ 82 /*....................*/ 83 84 if (f->pool) { 85 snd_seq_pool_done(f->pool); 86 snd_seq_pool_delete(&f->pool); 87 } 88 89 kfree(f); 90 } 91 92 static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f); 93 94 /* clear queue */ 95 void snd_seq_fifo_clear(struct snd_seq_fifo *f) 96 { 97 struct snd_seq_event_cell *cell; 98 unsigned long flags; 99 100 /* clear overflow flag */ 101 atomic_set(&f->overflow, 0); 102 103 snd_use_lock_sync(&f->use_lock); 104 spin_lock_irqsave(&f->lock, flags); 105 /* drain the fifo */ 106 while ((cell = fifo_cell_out(f)) != NULL) { 107 snd_seq_cell_free(cell); 108 } 109 spin_unlock_irqrestore(&f->lock, flags); 110 } 111 112 113 /* enqueue event to fifo */ 114 int snd_seq_fifo_event_in(struct snd_seq_fifo *f, 115 struct snd_seq_event *event) 116 { 117 struct snd_seq_event_cell *cell; 118 unsigned long flags; 119 int err; 120 121 if (snd_BUG_ON(!f)) 122 return -EINVAL; 123 124 snd_use_lock_use(&f->use_lock); 125 err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL); /* always non-blocking */ 126 if (err < 0) { 127 if ((err == -ENOMEM) || (err == -EAGAIN)) 128 atomic_inc(&f->overflow); 129 snd_use_lock_free(&f->use_lock); 130 return err; 131 } 132 133 /* append new cells to fifo */ 134 spin_lock_irqsave(&f->lock, flags); 135 if (f->tail != NULL) 136 f->tail->next = cell; 137 f->tail = cell; 138 if (f->head == NULL) 139 f->head = cell; 140 cell->next = NULL; 141 f->cells++; 142 spin_unlock_irqrestore(&f->lock, flags); 143 144 /* wakeup client */ 145 if (waitqueue_active(&f->input_sleep)) 146 wake_up(&f->input_sleep); 147 148 snd_use_lock_free(&f->use_lock); 149 150 return 0; /* success */ 151 152 } 153 154 /* dequeue cell from fifo */ 155 static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f) 156 { 157 struct snd_seq_event_cell *cell; 158 159 if ((cell = f->head) != NULL) { 160 f->head = cell->next; 161 162 /* reset tail if this was the last element */ 163 if (f->tail == cell) 164 f->tail = NULL; 165 166 cell->next = NULL; 167 f->cells--; 168 } 169 170 return cell; 171 } 172 173 /* dequeue cell from fifo and copy on user space */ 174 int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, 175 struct snd_seq_event_cell **cellp, int nonblock) 176 { 177 struct snd_seq_event_cell *cell; 178 unsigned long flags; 179 wait_queue_t wait; 180 181 if (snd_BUG_ON(!f)) 182 return -EINVAL; 183 184 *cellp = NULL; 185 init_waitqueue_entry(&wait, current); 186 spin_lock_irqsave(&f->lock, flags); 187 while ((cell = fifo_cell_out(f)) == NULL) { 188 if (nonblock) { 189 /* non-blocking - return immediately */ 190 spin_unlock_irqrestore(&f->lock, flags); 191 return -EAGAIN; 192 } 193 set_current_state(TASK_INTERRUPTIBLE); 194 add_wait_queue(&f->input_sleep, &wait); 195 spin_unlock_irq(&f->lock); 196 schedule(); 197 spin_lock_irq(&f->lock); 198 remove_wait_queue(&f->input_sleep, &wait); 199 if (signal_pending(current)) { 200 spin_unlock_irqrestore(&f->lock, flags); 201 return -ERESTARTSYS; 202 } 203 } 204 spin_unlock_irqrestore(&f->lock, flags); 205 *cellp = cell; 206 207 return 0; 208 } 209 210 211 void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, 212 struct snd_seq_event_cell *cell) 213 { 214 unsigned long flags; 215 216 if (cell) { 217 spin_lock_irqsave(&f->lock, flags); 218 cell->next = f->head; 219 f->head = cell; 220 if (!f->tail) 221 f->tail = cell; 222 f->cells++; 223 spin_unlock_irqrestore(&f->lock, flags); 224 } 225 } 226 227 228 /* polling; return non-zero if queue is available */ 229 int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file, 230 poll_table *wait) 231 { 232 poll_wait(file, &f->input_sleep, wait); 233 return (f->cells > 0); 234 } 235 236 /* change the size of pool; all old events are removed */ 237 int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize) 238 { 239 unsigned long flags; 240 struct snd_seq_pool *newpool, *oldpool; 241 struct snd_seq_event_cell *cell, *next, *oldhead; 242 243 if (snd_BUG_ON(!f || !f->pool)) 244 return -EINVAL; 245 246 /* allocate new pool */ 247 newpool = snd_seq_pool_new(poolsize); 248 if (newpool == NULL) 249 return -ENOMEM; 250 if (snd_seq_pool_init(newpool) < 0) { 251 snd_seq_pool_delete(&newpool); 252 return -ENOMEM; 253 } 254 255 spin_lock_irqsave(&f->lock, flags); 256 /* remember old pool */ 257 oldpool = f->pool; 258 oldhead = f->head; 259 /* exchange pools */ 260 f->pool = newpool; 261 f->head = NULL; 262 f->tail = NULL; 263 f->cells = 0; 264 /* NOTE: overflow flag is not cleared */ 265 spin_unlock_irqrestore(&f->lock, flags); 266 267 /* release cells in old pool */ 268 for (cell = oldhead; cell; cell = next) { 269 next = cell->next; 270 snd_seq_cell_free(cell); 271 } 272 snd_seq_pool_delete(&oldpool); 273 274 return 0; 275 } 276