[ALSA] Remove xxx_t typedefs: ISA SB8/SB16/SBAWE
[linux-2.6.git] / sound / isa / sb / sb8_midi.c
1 /*
2  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3  *  Routines for control of SoundBlaster cards - MIDI interface
4  *
5  *   This program is free software; you can redistribute it and/or modify
6  *   it under the terms of the GNU General Public License as published by
7  *   the Free Software Foundation; either version 2 of the License, or
8  *   (at your option) any later version.
9  *
10  *   This program is distributed in the hope that it will be useful,
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *   GNU General Public License for more details.
14  *
15  *   You should have received a copy of the GNU General Public License
16  *   along with this program; if not, write to the Free Software
17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18  *
19  * --
20  *
21  * Sun May  9 22:54:38 BST 1999 George David Morrison <gdm@gedamo.demon.co.uk>
22  *   Fixed typo in snd_sb8dsp_midi_new_device which prevented midi from 
23  *   working.
24  *
25  * Sun May 11 12:34:56 UTC 2003 Clemens Ladisch <clemens@ladisch.de>
26  *   Added full duplex UART mode for DSP version 2.0 and later.
27  */
28
29 #include <sound/driver.h>
30 #include <asm/io.h>
31 #include <linux/time.h>
32 #include <sound/core.h>
33 #include <sound/sb.h>
34
35 /*
36
37  */
38
39 irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb * chip)
40 {
41         struct snd_rawmidi *rmidi;
42         int max = 64;
43         char byte;
44
45         if (chip == NULL || (rmidi = chip->rmidi) == NULL) {
46                 inb(SBP(chip, DATA_AVAIL));     /* ack interrupt */
47                 return IRQ_NONE;
48         }
49         spin_lock(&chip->midi_input_lock);
50         while (max-- > 0) {
51                 if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
52                         byte = inb(SBP(chip, READ));
53                         if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
54                                 snd_rawmidi_receive(chip->midi_substream_input, &byte, 1);
55                         }
56                 }
57         }
58         spin_unlock(&chip->midi_input_lock);
59         return IRQ_HANDLED;
60 }
61
62 /*
63
64  */
65
66 static int snd_sb8dsp_midi_input_open(struct snd_rawmidi_substream *substream)
67 {
68         unsigned long flags;
69         struct snd_sb *chip;
70         unsigned int valid_open_flags;
71
72         chip = substream->rmidi->private_data;
73         valid_open_flags = chip->hardware >= SB_HW_20
74                 ? SB_OPEN_MIDI_OUTPUT | SB_OPEN_MIDI_OUTPUT_TRIGGER : 0;
75         spin_lock_irqsave(&chip->open_lock, flags);
76         if (chip->open & ~valid_open_flags) {
77                 spin_unlock_irqrestore(&chip->open_lock, flags);
78                 return -EAGAIN;
79         }
80         chip->open |= SB_OPEN_MIDI_INPUT;
81         chip->midi_substream_input = substream;
82         if (!(chip->open & SB_OPEN_MIDI_OUTPUT)) {
83                 spin_unlock_irqrestore(&chip->open_lock, flags);
84                 snd_sbdsp_reset(chip);          /* reset DSP */
85                 if (chip->hardware >= SB_HW_20)
86                         snd_sbdsp_command(chip, SB_DSP_MIDI_UART_IRQ);
87         } else {
88                 spin_unlock_irqrestore(&chip->open_lock, flags);
89         }
90         return 0;
91 }
92
93 static int snd_sb8dsp_midi_output_open(struct snd_rawmidi_substream *substream)
94 {
95         unsigned long flags;
96         struct snd_sb *chip;
97         unsigned int valid_open_flags;
98
99         chip = substream->rmidi->private_data;
100         valid_open_flags = chip->hardware >= SB_HW_20
101                 ? SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_INPUT_TRIGGER : 0;
102         spin_lock_irqsave(&chip->open_lock, flags);
103         if (chip->open & ~valid_open_flags) {
104                 spin_unlock_irqrestore(&chip->open_lock, flags);
105                 return -EAGAIN;
106         }
107         chip->open |= SB_OPEN_MIDI_OUTPUT;
108         chip->midi_substream_output = substream;
109         if (!(chip->open & SB_OPEN_MIDI_INPUT)) {
110                 spin_unlock_irqrestore(&chip->open_lock, flags);
111                 snd_sbdsp_reset(chip);          /* reset DSP */
112                 if (chip->hardware >= SB_HW_20)
113                         snd_sbdsp_command(chip, SB_DSP_MIDI_UART_IRQ);
114         } else {
115                 spin_unlock_irqrestore(&chip->open_lock, flags);
116         }
117         return 0;
118 }
119
120 static int snd_sb8dsp_midi_input_close(struct snd_rawmidi_substream *substream)
121 {
122         unsigned long flags;
123         struct snd_sb *chip;
124
125         chip = substream->rmidi->private_data;
126         spin_lock_irqsave(&chip->open_lock, flags);
127         chip->open &= ~(SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_INPUT_TRIGGER);
128         chip->midi_substream_input = NULL;
129         if (!(chip->open & SB_OPEN_MIDI_OUTPUT)) {
130                 spin_unlock_irqrestore(&chip->open_lock, flags);
131                 snd_sbdsp_reset(chip);          /* reset DSP */
132         } else {
133                 spin_unlock_irqrestore(&chip->open_lock, flags);
134         }
135         return 0;
136 }
137
138 static int snd_sb8dsp_midi_output_close(struct snd_rawmidi_substream *substream)
139 {
140         unsigned long flags;
141         struct snd_sb *chip;
142
143         chip = substream->rmidi->private_data;
144         spin_lock_irqsave(&chip->open_lock, flags);
145         chip->open &= ~(SB_OPEN_MIDI_OUTPUT | SB_OPEN_MIDI_OUTPUT_TRIGGER);
146         chip->midi_substream_output = NULL;
147         if (!(chip->open & SB_OPEN_MIDI_INPUT)) {
148                 spin_unlock_irqrestore(&chip->open_lock, flags);
149                 snd_sbdsp_reset(chip);          /* reset DSP */
150         } else {
151                 spin_unlock_irqrestore(&chip->open_lock, flags);
152         }
153         return 0;
154 }
155
156 static void snd_sb8dsp_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
157 {
158         unsigned long flags;
159         struct snd_sb *chip;
160
161         chip = substream->rmidi->private_data;
162         spin_lock_irqsave(&chip->open_lock, flags);
163         if (up) {
164                 if (!(chip->open & SB_OPEN_MIDI_INPUT_TRIGGER)) {
165                         if (chip->hardware < SB_HW_20)
166                                 snd_sbdsp_command(chip, SB_DSP_MIDI_INPUT_IRQ);
167                         chip->open |= SB_OPEN_MIDI_INPUT_TRIGGER;
168                 }
169         } else {
170                 if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
171                         if (chip->hardware < SB_HW_20)
172                                 snd_sbdsp_command(chip, SB_DSP_MIDI_INPUT_IRQ);
173                         chip->open &= ~SB_OPEN_MIDI_INPUT_TRIGGER;
174                 }
175         }
176         spin_unlock_irqrestore(&chip->open_lock, flags);
177 }
178
179 static void snd_sb8dsp_midi_output_write(struct snd_rawmidi_substream *substream)
180 {
181         unsigned long flags;
182         struct snd_sb *chip;
183         char byte;
184         int max = 32;
185
186         /* how big is Tx FIFO? */
187         chip = substream->rmidi->private_data;
188         while (max-- > 0) {
189                 spin_lock_irqsave(&chip->open_lock, flags);
190                 if (snd_rawmidi_transmit_peek(substream, &byte, 1) != 1) {
191                         chip->open &= ~SB_OPEN_MIDI_OUTPUT_TRIGGER;
192                         del_timer(&chip->midi_timer);
193                         spin_unlock_irqrestore(&chip->open_lock, flags);
194                         break;
195                 }
196                 if (chip->hardware >= SB_HW_20) {
197                         int timeout = 8;
198                         while ((inb(SBP(chip, STATUS)) & 0x80) != 0 && --timeout > 0)
199                                 ;
200                         if (timeout == 0) {
201                                 /* Tx FIFO full - try again later */
202                                 spin_unlock_irqrestore(&chip->open_lock, flags);
203                                 break;
204                         }
205                         outb(byte, SBP(chip, WRITE));
206                 } else {
207                         snd_sbdsp_command(chip, SB_DSP_MIDI_OUTPUT);
208                         snd_sbdsp_command(chip, byte);
209                 }
210                 snd_rawmidi_transmit_ack(substream, 1);
211                 spin_unlock_irqrestore(&chip->open_lock, flags);
212         }
213 }
214
215 static void snd_sb8dsp_midi_output_timer(unsigned long data)
216 {
217         struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *) data;
218         struct snd_sb * chip = substream->rmidi->private_data;
219         unsigned long flags;
220
221         spin_lock_irqsave(&chip->open_lock, flags);
222         chip->midi_timer.expires = 1 + jiffies;
223         add_timer(&chip->midi_timer);
224         spin_unlock_irqrestore(&chip->open_lock, flags);        
225         snd_sb8dsp_midi_output_write(substream);
226 }
227
228 static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
229 {
230         unsigned long flags;
231         struct snd_sb *chip;
232
233         chip = substream->rmidi->private_data;
234         spin_lock_irqsave(&chip->open_lock, flags);
235         if (up) {
236                 if (!(chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER)) {
237                         init_timer(&chip->midi_timer);
238                         chip->midi_timer.function = snd_sb8dsp_midi_output_timer;
239                         chip->midi_timer.data = (unsigned long) substream;
240                         chip->midi_timer.expires = 1 + jiffies;
241                         add_timer(&chip->midi_timer);
242                         chip->open |= SB_OPEN_MIDI_OUTPUT_TRIGGER;
243                 }
244         } else {
245                 if (chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER) {
246                         chip->open &= ~SB_OPEN_MIDI_OUTPUT_TRIGGER;
247                 }
248         }
249         spin_unlock_irqrestore(&chip->open_lock, flags);
250
251         if (up)
252                 snd_sb8dsp_midi_output_write(substream);
253 }
254
255 /*
256
257  */
258
259 static struct snd_rawmidi_ops snd_sb8dsp_midi_output =
260 {
261         .open =         snd_sb8dsp_midi_output_open,
262         .close =        snd_sb8dsp_midi_output_close,
263         .trigger =      snd_sb8dsp_midi_output_trigger,
264 };
265
266 static struct snd_rawmidi_ops snd_sb8dsp_midi_input =
267 {
268         .open =         snd_sb8dsp_midi_input_open,
269         .close =        snd_sb8dsp_midi_input_close,
270         .trigger =      snd_sb8dsp_midi_input_trigger,
271 };
272
273 int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi)
274 {
275         struct snd_rawmidi *rmidi;
276         int err;
277
278         if (rrawmidi)
279                 *rrawmidi = NULL;
280         if ((err = snd_rawmidi_new(chip->card, "SB8 MIDI", device, 1, 1, &rmidi)) < 0)
281                 return err;
282         strcpy(rmidi->name, "SB8 MIDI");
283         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_sb8dsp_midi_output);
284         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_sb8dsp_midi_input);
285         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT;
286         if (chip->hardware >= SB_HW_20)
287                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
288         rmidi->private_data = chip;
289         chip->rmidi = rmidi;
290         if (rrawmidi)
291                 *rrawmidi = rmidi;
292         return 0;
293 }