1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
31
32
33struct 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
64void 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 if (f->pool)
76 snd_seq_pool_mark_closing(f->pool);
77
78 snd_seq_fifo_clear(f);
79
80
81 if (waitqueue_active(&f->input_sleep))
82 wake_up(&f->input_sleep);
83
84
85
86
87 if (f->pool) {
88 snd_seq_pool_done(f->pool);
89 snd_seq_pool_delete(&f->pool);
90 }
91
92 kfree(f);
93}
94
95static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f);
96
97
98void snd_seq_fifo_clear(struct snd_seq_fifo *f)
99{
100 struct snd_seq_event_cell *cell;
101 unsigned long flags;
102
103
104 atomic_set(&f->overflow, 0);
105
106 snd_use_lock_sync(&f->use_lock);
107 spin_lock_irqsave(&f->lock, flags);
108
109 while ((cell = fifo_cell_out(f)) != NULL) {
110 snd_seq_cell_free(cell);
111 }
112 spin_unlock_irqrestore(&f->lock, flags);
113}
114
115
116
117int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
118 struct snd_seq_event *event)
119{
120 struct snd_seq_event_cell *cell;
121 unsigned long flags;
122 int err;
123
124 if (snd_BUG_ON(!f))
125 return -EINVAL;
126
127 snd_use_lock_use(&f->use_lock);
128 err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL);
129 if (err < 0) {
130 if ((err == -ENOMEM) || (err == -EAGAIN))
131 atomic_inc(&f->overflow);
132 snd_use_lock_free(&f->use_lock);
133 return err;
134 }
135
136
137 spin_lock_irqsave(&f->lock, flags);
138 if (f->tail != NULL)
139 f->tail->next = cell;
140 f->tail = cell;
141 if (f->head == NULL)
142 f->head = cell;
143 cell->next = NULL;
144 f->cells++;
145 spin_unlock_irqrestore(&f->lock, flags);
146
147
148 if (waitqueue_active(&f->input_sleep))
149 wake_up(&f->input_sleep);
150
151 snd_use_lock_free(&f->use_lock);
152
153 return 0;
154
155}
156
157
158static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f)
159{
160 struct snd_seq_event_cell *cell;
161
162 if ((cell = f->head) != NULL) {
163 f->head = cell->next;
164
165
166 if (f->tail == cell)
167 f->tail = NULL;
168
169 cell->next = NULL;
170 f->cells--;
171 }
172
173 return cell;
174}
175
176
177int snd_seq_fifo_cell_out(struct snd_seq_fifo *f,
178 struct snd_seq_event_cell **cellp, int nonblock)
179{
180 struct snd_seq_event_cell *cell;
181 unsigned long flags;
182 wait_queue_entry_t wait;
183
184 if (snd_BUG_ON(!f))
185 return -EINVAL;
186
187 *cellp = NULL;
188 init_waitqueue_entry(&wait, current);
189 spin_lock_irqsave(&f->lock, flags);
190 while ((cell = fifo_cell_out(f)) == NULL) {
191 if (nonblock) {
192
193 spin_unlock_irqrestore(&f->lock, flags);
194 return -EAGAIN;
195 }
196 set_current_state(TASK_INTERRUPTIBLE);
197 add_wait_queue(&f->input_sleep, &wait);
198 spin_unlock_irq(&f->lock);
199 schedule();
200 spin_lock_irq(&f->lock);
201 remove_wait_queue(&f->input_sleep, &wait);
202 if (signal_pending(current)) {
203 spin_unlock_irqrestore(&f->lock, flags);
204 return -ERESTARTSYS;
205 }
206 }
207 spin_unlock_irqrestore(&f->lock, flags);
208 *cellp = cell;
209
210 return 0;
211}
212
213
214void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f,
215 struct snd_seq_event_cell *cell)
216{
217 unsigned long flags;
218
219 if (cell) {
220 spin_lock_irqsave(&f->lock, flags);
221 cell->next = f->head;
222 f->head = cell;
223 if (!f->tail)
224 f->tail = cell;
225 f->cells++;
226 spin_unlock_irqrestore(&f->lock, flags);
227 }
228}
229
230
231
232int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file,
233 poll_table *wait)
234{
235 poll_wait(file, &f->input_sleep, wait);
236 return (f->cells > 0);
237}
238
239
240int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
241{
242 unsigned long flags;
243 struct snd_seq_pool *newpool, *oldpool;
244 struct snd_seq_event_cell *cell, *next, *oldhead;
245
246 if (snd_BUG_ON(!f || !f->pool))
247 return -EINVAL;
248
249
250 newpool = snd_seq_pool_new(poolsize);
251 if (newpool == NULL)
252 return -ENOMEM;
253 if (snd_seq_pool_init(newpool) < 0) {
254 snd_seq_pool_delete(&newpool);
255 return -ENOMEM;
256 }
257
258 spin_lock_irqsave(&f->lock, flags);
259
260 oldpool = f->pool;
261 oldhead = f->head;
262
263 f->pool = newpool;
264 f->head = NULL;
265 f->tail = NULL;
266 f->cells = 0;
267
268 spin_unlock_irqrestore(&f->lock, flags);
269
270
271 snd_seq_pool_mark_closing(oldpool);
272 snd_use_lock_sync(&f->use_lock);
273
274
275 for (cell = oldhead; cell; cell = next) {
276 next = cell->next;
277 snd_seq_cell_free(cell);
278 }
279 snd_seq_pool_delete(&oldpool);
280
281 return 0;
282}
283