[ALSA] Remove xxx_t typedefs: Sequencer OSS-emulation
[linux-2.6.git] / sound / core / seq / oss / seq_oss_writeq.c
1 /*
2  * OSS compatible sequencer driver
3  *
4  * seq_oss_writeq.c - write queue and sync
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_writeq.h"
24 #include "seq_oss_event.h"
25 #include "seq_oss_timer.h"
26 #include <sound/seq_oss_legacy.h>
27 #include "../seq_lock.h"
28 #include "../seq_clientmgr.h"
29 #include <linux/wait.h>
30
31
32 /*
33  * create a write queue record
34  */
35 struct seq_oss_writeq *
36 snd_seq_oss_writeq_new(struct seq_oss_devinfo *dp, int maxlen)
37 {
38         struct seq_oss_writeq *q;
39         struct snd_seq_client_pool pool;
40
41         if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL)
42                 return NULL;
43         q->dp = dp;
44         q->maxlen = maxlen;
45         spin_lock_init(&q->sync_lock);
46         q->sync_event_put = 0;
47         q->sync_time = 0;
48         init_waitqueue_head(&q->sync_sleep);
49
50         memset(&pool, 0, sizeof(pool));
51         pool.client = dp->cseq;
52         pool.output_pool = maxlen;
53         pool.output_room = maxlen / 2;
54
55         snd_seq_oss_control(dp, SNDRV_SEQ_IOCTL_SET_CLIENT_POOL, &pool);
56
57         return q;
58 }
59
60 /*
61  * delete the write queue
62  */
63 void
64 snd_seq_oss_writeq_delete(struct seq_oss_writeq *q)
65 {
66         snd_seq_oss_writeq_clear(q);    /* to be sure */
67         kfree(q);
68 }
69
70
71 /*
72  * reset the write queue
73  */
74 void
75 snd_seq_oss_writeq_clear(struct seq_oss_writeq *q)
76 {
77         struct snd_seq_remove_events reset;
78
79         memset(&reset, 0, sizeof(reset));
80         reset.remove_mode = SNDRV_SEQ_REMOVE_OUTPUT; /* remove all */
81         snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_REMOVE_EVENTS, &reset);
82
83         /* wake up sleepers if any */
84         snd_seq_oss_writeq_wakeup(q, 0);
85 }
86
87 /*
88  * wait until the write buffer has enough room
89  */
90 int
91 snd_seq_oss_writeq_sync(struct seq_oss_writeq *q)
92 {
93         struct seq_oss_devinfo *dp = q->dp;
94         abstime_t time;
95
96         time = snd_seq_oss_timer_cur_tick(dp->timer);
97         if (q->sync_time >= time)
98                 return 0; /* already finished */
99
100         if (! q->sync_event_put) {
101                 struct snd_seq_event ev;
102                 union evrec *rec;
103
104                 /* put echoback event */
105                 memset(&ev, 0, sizeof(ev));
106                 ev.flags = 0;
107                 ev.type = SNDRV_SEQ_EVENT_ECHO;
108                 ev.time.tick = time;
109                 /* echo back to itself */
110                 snd_seq_oss_fill_addr(dp, &ev, dp->addr.client, dp->addr.port);
111                 rec = (union evrec *)&ev.data;
112                 rec->t.code = SEQ_SYNCTIMER;
113                 rec->t.time = time;
114                 q->sync_event_put = 1;
115                 snd_seq_kernel_client_enqueue_blocking(dp->cseq, &ev, NULL, 0, 0);
116         }
117
118         wait_event_interruptible_timeout(q->sync_sleep, ! q->sync_event_put, HZ);
119         if (signal_pending(current))
120                 /* interrupted - return 0 to finish sync */
121                 q->sync_event_put = 0;
122         if (! q->sync_event_put || q->sync_time >= time)
123                 return 0;
124         return 1;
125 }
126
127 /*
128  * wake up sync - echo event was catched
129  */
130 void
131 snd_seq_oss_writeq_wakeup(struct seq_oss_writeq *q, abstime_t time)
132 {
133         unsigned long flags;
134
135         spin_lock_irqsave(&q->sync_lock, flags);
136         q->sync_time = time;
137         q->sync_event_put = 0;
138         if (waitqueue_active(&q->sync_sleep)) {
139                 wake_up(&q->sync_sleep);
140         }
141         spin_unlock_irqrestore(&q->sync_lock, flags);
142 }
143
144
145 /*
146  * return the unused pool size
147  */
148 int
149 snd_seq_oss_writeq_get_free_size(struct seq_oss_writeq *q)
150 {
151         struct snd_seq_client_pool pool;
152         pool.client = q->dp->cseq;
153         snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, &pool);
154         return pool.output_free;
155 }
156
157
158 /*
159  * set output threshold size from ioctl
160  */
161 void
162 snd_seq_oss_writeq_set_output(struct seq_oss_writeq *q, int val)
163 {
164         struct snd_seq_client_pool pool;
165         pool.client = q->dp->cseq;
166         snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, &pool);
167         pool.output_room = val;
168         snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_SET_CLIENT_POOL, &pool);
169 }
170