Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394...
[linux-2.6] / sound / pci / ca0106 / ca_midi.c
1 /* 
2  *  Copyright 10/16/2005 Tilman Kranz <tilde@tk-sls.de>
3  *  Creative Audio MIDI, for the CA0106 Driver
4  *  Version: 0.0.1
5  *
6  *  Changelog:
7  *    Implementation is based on mpu401 and emu10k1x and
8  *    tested with ca0106.
9  *    mpu401: Copyright (c) by Jaroslav Kysela <perex@perex.cz>
10  *    emu10k1x: Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
11  *
12  *   This program is free software; you can redistribute it and/or modify
13  *   it under the terms of the GNU General Public License as published by
14  *   the Free Software Foundation; either version 2 of the License, or
15  *   (at your option) any later version.
16  *
17  *   This program is distributed in the hope that it will be useful,
18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *   GNU General Public License for more details.
21  *
22  *   You should have received a copy of the GNU General Public License
23  *   along with this program; if not, write to the Free Software
24  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
25  *
26  *
27  */
28
29 #include <linux/spinlock.h>
30 #include <sound/core.h>
31 #include <sound/rawmidi.h>
32
33 #include "ca_midi.h"
34
35 #define ca_midi_write_data(midi, data)  midi->write(midi, data, 0)
36 #define ca_midi_write_cmd(midi, data)   midi->write(midi, data, 1)
37 #define ca_midi_read_data(midi)         midi->read(midi, 0)
38 #define ca_midi_read_stat(midi)         midi->read(midi, 1)
39 #define ca_midi_input_avail(midi)       (!(ca_midi_read_stat(midi) & midi->input_avail))
40 #define ca_midi_output_ready(midi)      (!(ca_midi_read_stat(midi) & midi->output_ready))
41
42 static void ca_midi_clear_rx(struct snd_ca_midi *midi)
43 {
44         int timeout = 100000;
45         for (; timeout > 0 && ca_midi_input_avail(midi); timeout--)
46                 ca_midi_read_data(midi);
47 #ifdef CONFIG_SND_DEBUG
48         if (timeout <= 0)
49                 snd_printk(KERN_ERR "ca_midi_clear_rx: timeout (status = 0x%x)\n",
50                            ca_midi_read_stat(midi));
51 #endif
52 }
53
54 static void ca_midi_interrupt(struct snd_ca_midi *midi, unsigned int status)
55 {
56         unsigned char byte;
57
58         if (midi->rmidi == NULL) {
59                 midi->interrupt_disable(midi,midi->tx_enable | midi->rx_enable);
60                 return;
61         }
62
63         spin_lock(&midi->input_lock);
64         if ((status & midi->ipr_rx) && ca_midi_input_avail(midi)) {
65                 if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
66                         ca_midi_clear_rx(midi);
67                 } else {
68                         byte = ca_midi_read_data(midi);
69                         if(midi->substream_input)
70                                 snd_rawmidi_receive(midi->substream_input, &byte, 1);
71
72
73                 }
74         }
75         spin_unlock(&midi->input_lock);
76
77         spin_lock(&midi->output_lock);
78         if ((status & midi->ipr_tx) && ca_midi_output_ready(midi)) {
79                 if (midi->substream_output &&
80                     snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
81                         ca_midi_write_data(midi, byte);
82                 } else {
83                         midi->interrupt_disable(midi,midi->tx_enable);
84                 }
85         }
86         spin_unlock(&midi->output_lock);
87
88 }
89
90 static void ca_midi_cmd(struct snd_ca_midi *midi, unsigned char cmd, int ack)
91 {
92         unsigned long flags;
93         int timeout, ok;
94
95         spin_lock_irqsave(&midi->input_lock, flags);
96         ca_midi_write_data(midi, 0x00);
97         /* ca_midi_clear_rx(midi); */
98
99         ca_midi_write_cmd(midi, cmd);
100         if (ack) {
101                 ok = 0;
102                 timeout = 10000;
103                 while (!ok && timeout-- > 0) {
104                         if (ca_midi_input_avail(midi)) {
105                                 if (ca_midi_read_data(midi) == midi->ack)
106                                         ok = 1;
107                         }
108                 }
109                 if (!ok && ca_midi_read_data(midi) == midi->ack)
110                         ok = 1;
111         } else {
112                 ok = 1;
113         }
114         spin_unlock_irqrestore(&midi->input_lock, flags);
115         if (!ok)
116                 snd_printk(KERN_ERR "ca_midi_cmd: 0x%x failed at 0x%x (status = 0x%x, data = 0x%x)!!!\n",
117                            cmd,
118                            midi->get_dev_id_port(midi->dev_id),
119                            ca_midi_read_stat(midi),
120                            ca_midi_read_data(midi));
121 }
122
123 static int ca_midi_input_open(struct snd_rawmidi_substream *substream)
124 {
125         struct snd_ca_midi *midi = substream->rmidi->private_data;
126         unsigned long flags;
127         
128         snd_assert(midi->dev_id, return -ENXIO);
129         spin_lock_irqsave(&midi->open_lock, flags);
130         midi->midi_mode |= CA_MIDI_MODE_INPUT;
131         midi->substream_input = substream;
132         if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT)) {
133                 spin_unlock_irqrestore(&midi->open_lock, flags);
134                 ca_midi_cmd(midi, midi->reset, 1);
135                 ca_midi_cmd(midi, midi->enter_uart, 1);
136         } else {
137                 spin_unlock_irqrestore(&midi->open_lock, flags);
138         }
139         return 0;
140 }
141
142 static int ca_midi_output_open(struct snd_rawmidi_substream *substream)
143 {
144         struct snd_ca_midi *midi = substream->rmidi->private_data;
145         unsigned long flags;
146
147         snd_assert(midi->dev_id, return -ENXIO);
148         spin_lock_irqsave(&midi->open_lock, flags);
149         midi->midi_mode |= CA_MIDI_MODE_OUTPUT;
150         midi->substream_output = substream;
151         if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
152                 spin_unlock_irqrestore(&midi->open_lock, flags);
153                 ca_midi_cmd(midi, midi->reset, 1);
154                 ca_midi_cmd(midi, midi->enter_uart, 1);
155         } else {
156                 spin_unlock_irqrestore(&midi->open_lock, flags);
157         }
158         return 0;
159 }
160
161 static int ca_midi_input_close(struct snd_rawmidi_substream *substream)
162 {
163         struct snd_ca_midi *midi = substream->rmidi->private_data;
164         unsigned long flags;
165
166         snd_assert(midi->dev_id, return -ENXIO);
167         spin_lock_irqsave(&midi->open_lock, flags);
168         midi->interrupt_disable(midi,midi->rx_enable);
169         midi->midi_mode &= ~CA_MIDI_MODE_INPUT;
170         midi->substream_input = NULL;
171         if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT)) {
172                 spin_unlock_irqrestore(&midi->open_lock, flags);
173                 ca_midi_cmd(midi, midi->reset, 0);
174         } else {
175                 spin_unlock_irqrestore(&midi->open_lock, flags);
176         }
177         return 0;
178 }
179
180 static int ca_midi_output_close(struct snd_rawmidi_substream *substream)
181 {
182         struct snd_ca_midi *midi = substream->rmidi->private_data;
183         unsigned long flags;
184         snd_assert(midi->dev_id, return -ENXIO);
185         
186         spin_lock_irqsave(&midi->open_lock, flags);
187
188         midi->interrupt_disable(midi,midi->tx_enable);
189         midi->midi_mode &= ~CA_MIDI_MODE_OUTPUT;
190         midi->substream_output = NULL;
191         
192         if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
193                 spin_unlock_irqrestore(&midi->open_lock, flags);
194                 ca_midi_cmd(midi, midi->reset, 0);
195         } else {
196                 spin_unlock_irqrestore(&midi->open_lock, flags);
197         }
198         return 0;
199 }
200
201 static void ca_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
202 {
203         struct snd_ca_midi *midi = substream->rmidi->private_data;
204         snd_assert(midi->dev_id, return);
205
206         if (up) {
207                 midi->interrupt_enable(midi,midi->rx_enable);
208         } else {
209                 midi->interrupt_disable(midi, midi->rx_enable);
210         }
211 }
212
213 static void ca_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
214 {
215         struct snd_ca_midi *midi = substream->rmidi->private_data;
216         unsigned long flags;
217
218         snd_assert(midi->dev_id, return);
219
220         if (up) {
221                 int max = 4;
222                 unsigned char byte;
223
224                 spin_lock_irqsave(&midi->output_lock, flags);
225         
226                 /* try to send some amount of bytes here before interrupts */
227                 while (max > 0) {
228                         if (ca_midi_output_ready(midi)) {
229                                 if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT) ||
230                                     snd_rawmidi_transmit(substream, &byte, 1) != 1) {
231                                         /* no more data */
232                                         spin_unlock_irqrestore(&midi->output_lock, flags);
233                                         return;
234                                 }
235                                 ca_midi_write_data(midi, byte);
236                                 max--;
237                         } else {
238                                 break;
239                         }
240                 }
241
242                 spin_unlock_irqrestore(&midi->output_lock, flags);
243                 midi->interrupt_enable(midi,midi->tx_enable);
244
245         } else {
246                 midi->interrupt_disable(midi,midi->tx_enable);
247         }
248 }
249
250 static struct snd_rawmidi_ops ca_midi_output =
251 {
252         .open =         ca_midi_output_open,
253         .close =        ca_midi_output_close,
254         .trigger =      ca_midi_output_trigger,
255 };
256
257 static struct snd_rawmidi_ops ca_midi_input =
258 {
259         .open =         ca_midi_input_open,
260         .close =        ca_midi_input_close,
261         .trigger =      ca_midi_input_trigger,
262 };
263
264 static void ca_midi_free(struct snd_ca_midi *midi)
265 {
266         midi->interrupt = NULL;
267         midi->interrupt_enable = NULL;
268         midi->interrupt_disable = NULL;
269         midi->read = NULL;
270         midi->write = NULL;
271         midi->get_dev_id_card = NULL;
272         midi->get_dev_id_port = NULL;
273         midi->rmidi = NULL;
274 }
275
276 static void ca_rmidi_free(struct snd_rawmidi *rmidi)
277 {
278         ca_midi_free(rmidi->private_data);
279 }
280
281 int __devinit ca_midi_init(void *dev_id, struct snd_ca_midi *midi, int device, char *name)
282 {
283         struct snd_rawmidi *rmidi;
284         int err;
285
286         if ((err = snd_rawmidi_new(midi->get_dev_id_card(midi->dev_id), name, device, 1, 1, &rmidi)) < 0)
287                 return err;
288
289         midi->dev_id = dev_id;
290         midi->interrupt = ca_midi_interrupt;
291
292         spin_lock_init(&midi->open_lock);
293         spin_lock_init(&midi->input_lock);
294         spin_lock_init(&midi->output_lock);
295
296         strcpy(rmidi->name, name);
297         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &ca_midi_output);
298         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &ca_midi_input);
299         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
300                              SNDRV_RAWMIDI_INFO_INPUT |
301                              SNDRV_RAWMIDI_INFO_DUPLEX;
302         rmidi->private_data = midi;
303         rmidi->private_free = ca_rmidi_free;
304         
305         midi->rmidi = rmidi;
306         return 0;
307 }
308