Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/x86
[linux-2.6] / sound / core / seq / oss / seq_oss_readq.c
1 /*
2  * OSS compatible sequencer driver
3  *
4  * seq_oss_readq.c - MIDI input queue
5  *
6  * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  */
22
23 #include "seq_oss_readq.h"
24 #include "seq_oss_event.h"
25 #include <sound/seq_oss_legacy.h>
26 #include "../seq_lock.h"
27 #include <linux/wait.h>
28
29 /*
30  * constants
31  */
32 //#define SNDRV_SEQ_OSS_MAX_TIMEOUT     (unsigned long)(-1)
33 #define SNDRV_SEQ_OSS_MAX_TIMEOUT       (HZ * 3600)
34
35
36 /*
37  * prototypes
38  */
39
40
41 /*
42  * create a read queue
43  */
44 struct seq_oss_readq *
45 snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen)
46 {
47         struct seq_oss_readq *q;
48
49         if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) {
50                 snd_printk(KERN_ERR "can't malloc read queue\n");
51                 return NULL;
52         }
53
54         if ((q->q = kcalloc(maxlen, sizeof(union evrec), GFP_KERNEL)) == NULL) {
55                 snd_printk(KERN_ERR "can't malloc read queue buffer\n");
56                 kfree(q);
57                 return NULL;
58         }
59
60         q->maxlen = maxlen;
61         q->qlen = 0;
62         q->head = q->tail = 0;
63         init_waitqueue_head(&q->midi_sleep);
64         spin_lock_init(&q->lock);
65         q->pre_event_timeout = SNDRV_SEQ_OSS_MAX_TIMEOUT;
66         q->input_time = (unsigned long)-1;
67
68         return q;
69 }
70
71 /*
72  * delete the read queue
73  */
74 void
75 snd_seq_oss_readq_delete(struct seq_oss_readq *q)
76 {
77         if (q) {
78                 kfree(q->q);
79                 kfree(q);
80         }
81 }
82
83 /*
84  * reset the read queue
85  */
86 void
87 snd_seq_oss_readq_clear(struct seq_oss_readq *q)
88 {
89         if (q->qlen) {
90                 q->qlen = 0;
91                 q->head = q->tail = 0;
92         }
93         /* if someone sleeping, wake'em up */
94         if (waitqueue_active(&q->midi_sleep))
95                 wake_up(&q->midi_sleep);
96         q->input_time = (unsigned long)-1;
97 }
98
99 /*
100  * put a midi byte
101  */
102 int
103 snd_seq_oss_readq_puts(struct seq_oss_readq *q, int dev, unsigned char *data, int len)
104 {
105         union evrec rec;
106         int result;
107
108         memset(&rec, 0, sizeof(rec));
109         rec.c[0] = SEQ_MIDIPUTC;
110         rec.c[2] = dev;
111
112         while (len-- > 0) {
113                 rec.c[1] = *data++;
114                 result = snd_seq_oss_readq_put_event(q, &rec);
115                 if (result < 0)
116                         return result;
117         }
118         return 0;
119 }
120
121 /*
122  * copy an event to input queue:
123  * return zero if enqueued
124  */
125 int
126 snd_seq_oss_readq_put_event(struct seq_oss_readq *q, union evrec *ev)
127 {
128         unsigned long flags;
129
130         spin_lock_irqsave(&q->lock, flags);
131         if (q->qlen >= q->maxlen - 1) {
132                 spin_unlock_irqrestore(&q->lock, flags);
133                 return -ENOMEM;
134         }
135
136         memcpy(&q->q[q->tail], ev, sizeof(*ev));
137         q->tail = (q->tail + 1) % q->maxlen;
138         q->qlen++;
139
140         /* wake up sleeper */
141         if (waitqueue_active(&q->midi_sleep))
142                 wake_up(&q->midi_sleep);
143
144         spin_unlock_irqrestore(&q->lock, flags);
145
146         return 0;
147 }
148
149
150 /*
151  * pop queue
152  * caller must hold lock
153  */
154 int
155 snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec)
156 {
157         if (q->qlen == 0)
158                 return -EAGAIN;
159         memcpy(rec, &q->q[q->head], sizeof(*rec));
160         return 0;
161 }
162
163 /*
164  * sleep until ready
165  */
166 void
167 snd_seq_oss_readq_wait(struct seq_oss_readq *q)
168 {
169         wait_event_interruptible_timeout(q->midi_sleep,
170                                          (q->qlen > 0 || q->head == q->tail),
171                                          q->pre_event_timeout);
172 }
173
174 /*
175  * drain one record
176  * caller must hold lock
177  */
178 void
179 snd_seq_oss_readq_free(struct seq_oss_readq *q)
180 {
181         if (q->qlen > 0) {
182                 q->head = (q->head + 1) % q->maxlen;
183                 q->qlen--;
184         }
185 }
186
187 /*
188  * polling/select:
189  * return non-zero if readq is not empty.
190  */
191 unsigned int
192 snd_seq_oss_readq_poll(struct seq_oss_readq *q, struct file *file, poll_table *wait)
193 {
194         poll_wait(file, &q->midi_sleep, wait);
195         return q->qlen;
196 }
197
198 /*
199  * put a timestamp
200  */
201 int
202 snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *q, unsigned long curt, int seq_mode)
203 {
204         if (curt != q->input_time) {
205                 union evrec rec;
206                 memset(&rec, 0, sizeof(rec));
207                 switch (seq_mode) {
208                 case SNDRV_SEQ_OSS_MODE_SYNTH:
209                         rec.echo = (curt << 8) | SEQ_WAIT;
210                         snd_seq_oss_readq_put_event(q, &rec);
211                         break;
212                 case SNDRV_SEQ_OSS_MODE_MUSIC:
213                         rec.t.code = EV_TIMING;
214                         rec.t.cmd = TMR_WAIT_ABS;
215                         rec.t.time = curt;
216                         snd_seq_oss_readq_put_event(q, &rec);
217                         break;
218                 }
219                 q->input_time = curt;
220         }
221         return 0;
222 }
223
224
225 #ifdef CONFIG_PROC_FS
226 /*
227  * proc interface
228  */
229 void
230 snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer *buf)
231 {
232         snd_iprintf(buf, "  read queue [%s] length = %d : tick = %ld\n",
233                     (waitqueue_active(&q->midi_sleep) ? "sleeping":"running"),
234                     q->qlen, q->input_time);
235 }
236 #endif /* CONFIG_PROC_FS */