[ALSA] Changed Jaroslav Kysela's e-mail from perex@suse.cz to perex@perex.cz
[linux-2.6.git] / sound / pci / emu10k1 / emumpu401.c
1 /*
2  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
3  *  Routines for control of EMU10K1 MPU-401 in UART mode
4  *
5  *
6  *   This program is free software; you can redistribute it and/or modify
7  *   it under the terms of the GNU General Public License as published by
8  *   the Free Software Foundation; either version 2 of the License, or
9  *   (at your option) any later version.
10  *
11  *   This program is distributed in the hope that it will be useful,
12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *   GNU General Public License for more details.
15  *
16  *   You should have received a copy of the GNU General Public License
17  *   along with this program; if not, write to the Free Software
18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19  *
20  */
21
22 #include <sound/driver.h>
23 #include <linux/time.h>
24 #include <linux/init.h>
25 #include <sound/core.h>
26 #include <sound/emu10k1.h>
27
28 #define EMU10K1_MIDI_MODE_INPUT         (1<<0)
29 #define EMU10K1_MIDI_MODE_OUTPUT        (1<<1)
30
31 static inline unsigned char mpu401_read(struct snd_emu10k1 *emu,
32                                         struct snd_emu10k1_midi *mpu, int idx)
33 {
34         if (emu->audigy)
35                 return (unsigned char)snd_emu10k1_ptr_read(emu, mpu->port + idx, 0);
36         else
37                 return inb(emu->port + mpu->port + idx);
38 }
39
40 static inline void mpu401_write(struct snd_emu10k1 *emu,
41                                 struct snd_emu10k1_midi *mpu, int data, int idx)
42 {
43         if (emu->audigy)
44                 snd_emu10k1_ptr_write(emu, mpu->port + idx, 0, data);
45         else
46                 outb(data, emu->port + mpu->port + idx);
47 }
48
49 #define mpu401_write_data(emu, mpu, data)       mpu401_write(emu, mpu, data, 0)
50 #define mpu401_write_cmd(emu, mpu, data)        mpu401_write(emu, mpu, data, 1)
51 #define mpu401_read_data(emu, mpu)              mpu401_read(emu, mpu, 0)
52 #define mpu401_read_stat(emu, mpu)              mpu401_read(emu, mpu, 1)
53
54 #define mpu401_input_avail(emu,mpu)     (!(mpu401_read_stat(emu,mpu) & 0x80))
55 #define mpu401_output_ready(emu,mpu)    (!(mpu401_read_stat(emu,mpu) & 0x40))
56
57 #define MPU401_RESET            0xff
58 #define MPU401_ENTER_UART       0x3f
59 #define MPU401_ACK              0xfe
60
61 static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu)
62 {
63         int timeout = 100000;
64         for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--)
65                 mpu401_read_data(emu, mpu);
66 #ifdef CONFIG_SND_DEBUG
67         if (timeout <= 0)
68                 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
69 #endif
70 }
71
72 /*
73
74  */
75
76 static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, unsigned int status)
77 {
78         unsigned char byte;
79
80         if (midi->rmidi == NULL) {
81                 snd_emu10k1_intr_disable(emu, midi->tx_enable | midi->rx_enable);
82                 return;
83         }
84
85         spin_lock(&midi->input_lock);
86         if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
87                 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
88                         mpu401_clear_rx(emu, midi);
89                 } else {
90                         byte = mpu401_read_data(emu, midi);
91                         if (midi->substream_input)
92                                 snd_rawmidi_receive(midi->substream_input, &byte, 1);
93                 }
94         }
95         spin_unlock(&midi->input_lock);
96
97         spin_lock(&midi->output_lock);
98         if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) {
99                 if (midi->substream_output &&
100                     snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
101                         mpu401_write_data(emu, midi, byte);
102                 } else {
103                         snd_emu10k1_intr_disable(emu, midi->tx_enable);
104                 }
105         }
106         spin_unlock(&midi->output_lock);
107 }
108
109 static void snd_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, unsigned int status)
110 {
111         do_emu10k1_midi_interrupt(emu, &emu->midi, status);
112 }
113
114 static void snd_emu10k1_midi_interrupt2(struct snd_emu10k1 *emu, unsigned int status)
115 {
116         do_emu10k1_midi_interrupt(emu, &emu->midi2, status);
117 }
118
119 static int snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_midi *midi, unsigned char cmd, int ack)
120 {
121         unsigned long flags;
122         int timeout, ok;
123
124         spin_lock_irqsave(&midi->input_lock, flags);
125         mpu401_write_data(emu, midi, 0x00);
126         /* mpu401_clear_rx(emu, midi); */
127
128         mpu401_write_cmd(emu, midi, cmd);
129         if (ack) {
130                 ok = 0;
131                 timeout = 10000;
132                 while (!ok && timeout-- > 0) {
133                         if (mpu401_input_avail(emu, midi)) {
134                                 if (mpu401_read_data(emu, midi) == MPU401_ACK)
135                                         ok = 1;
136                         }
137                 }
138                 if (!ok && mpu401_read_data(emu, midi) == MPU401_ACK)
139                         ok = 1;
140         } else {
141                 ok = 1;
142         }
143         spin_unlock_irqrestore(&midi->input_lock, flags);
144         if (!ok) {
145                 snd_printk(KERN_ERR "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
146                            cmd, emu->port,
147                            mpu401_read_stat(emu, midi),
148                            mpu401_read_data(emu, midi));
149                 return 1;
150         }
151         return 0;
152 }
153
154 static int snd_emu10k1_midi_input_open(struct snd_rawmidi_substream *substream)
155 {
156         struct snd_emu10k1 *emu;
157         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
158         unsigned long flags;
159
160         emu = midi->emu;
161         snd_assert(emu, return -ENXIO);
162         spin_lock_irqsave(&midi->open_lock, flags);
163         midi->midi_mode |= EMU10K1_MIDI_MODE_INPUT;
164         midi->substream_input = substream;
165         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
166                 spin_unlock_irqrestore(&midi->open_lock, flags);
167                 if (snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1))
168                         goto error_out;
169                 if (snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1))
170                         goto error_out;
171         } else {
172                 spin_unlock_irqrestore(&midi->open_lock, flags);
173         }
174         return 0;
175
176 error_out:
177         return -EIO;
178 }
179
180 static int snd_emu10k1_midi_output_open(struct snd_rawmidi_substream *substream)
181 {
182         struct snd_emu10k1 *emu;
183         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
184         unsigned long flags;
185
186         emu = midi->emu;
187         snd_assert(emu, return -ENXIO);
188         spin_lock_irqsave(&midi->open_lock, flags);
189         midi->midi_mode |= EMU10K1_MIDI_MODE_OUTPUT;
190         midi->substream_output = substream;
191         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
192                 spin_unlock_irqrestore(&midi->open_lock, flags);
193                 if (snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1))
194                         goto error_out;
195                 if (snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1))
196                         goto error_out;
197         } else {
198                 spin_unlock_irqrestore(&midi->open_lock, flags);
199         }
200         return 0;
201
202 error_out:
203         return -EIO;
204 }
205
206 static int snd_emu10k1_midi_input_close(struct snd_rawmidi_substream *substream)
207 {
208         struct snd_emu10k1 *emu;
209         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
210         unsigned long flags;
211         int err = 0;
212
213         emu = midi->emu;
214         snd_assert(emu, return -ENXIO);
215         spin_lock_irqsave(&midi->open_lock, flags);
216         snd_emu10k1_intr_disable(emu, midi->rx_enable);
217         midi->midi_mode &= ~EMU10K1_MIDI_MODE_INPUT;
218         midi->substream_input = NULL;
219         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
220                 spin_unlock_irqrestore(&midi->open_lock, flags);
221                 err = snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
222         } else {
223                 spin_unlock_irqrestore(&midi->open_lock, flags);
224         }
225         return err;
226 }
227
228 static int snd_emu10k1_midi_output_close(struct snd_rawmidi_substream *substream)
229 {
230         struct snd_emu10k1 *emu;
231         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
232         unsigned long flags;
233         int err = 0;
234
235         emu = midi->emu;
236         snd_assert(emu, return -ENXIO);
237         spin_lock_irqsave(&midi->open_lock, flags);
238         snd_emu10k1_intr_disable(emu, midi->tx_enable);
239         midi->midi_mode &= ~EMU10K1_MIDI_MODE_OUTPUT;
240         midi->substream_output = NULL;
241         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
242                 spin_unlock_irqrestore(&midi->open_lock, flags);
243                 err = snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
244         } else {
245                 spin_unlock_irqrestore(&midi->open_lock, flags);
246         }
247         return err;
248 }
249
250 static void snd_emu10k1_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
251 {
252         struct snd_emu10k1 *emu;
253         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
254         emu = midi->emu;
255         snd_assert(emu, return);
256
257         if (up)
258                 snd_emu10k1_intr_enable(emu, midi->rx_enable);
259         else
260                 snd_emu10k1_intr_disable(emu, midi->rx_enable);
261 }
262
263 static void snd_emu10k1_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
264 {
265         struct snd_emu10k1 *emu;
266         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
267         unsigned long flags;
268
269         emu = midi->emu;
270         snd_assert(emu, return);
271
272         if (up) {
273                 int max = 4;
274                 unsigned char byte;
275         
276                 /* try to send some amount of bytes here before interrupts */
277                 spin_lock_irqsave(&midi->output_lock, flags);
278                 while (max > 0) {
279                         if (mpu401_output_ready(emu, midi)) {
280                                 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT) ||
281                                     snd_rawmidi_transmit(substream, &byte, 1) != 1) {
282                                         /* no more data */
283                                         spin_unlock_irqrestore(&midi->output_lock, flags);
284                                         return;
285                                 }
286                                 mpu401_write_data(emu, midi, byte);
287                                 max--;
288                         } else {
289                                 break;
290                         }
291                 }
292                 spin_unlock_irqrestore(&midi->output_lock, flags);
293                 snd_emu10k1_intr_enable(emu, midi->tx_enable);
294         } else {
295                 snd_emu10k1_intr_disable(emu, midi->tx_enable);
296         }
297 }
298
299 /*
300
301  */
302
303 static struct snd_rawmidi_ops snd_emu10k1_midi_output =
304 {
305         .open =         snd_emu10k1_midi_output_open,
306         .close =        snd_emu10k1_midi_output_close,
307         .trigger =      snd_emu10k1_midi_output_trigger,
308 };
309
310 static struct snd_rawmidi_ops snd_emu10k1_midi_input =
311 {
312         .open =         snd_emu10k1_midi_input_open,
313         .close =        snd_emu10k1_midi_input_close,
314         .trigger =      snd_emu10k1_midi_input_trigger,
315 };
316
317 static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi)
318 {
319         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data;
320         midi->interrupt = NULL;
321         midi->rmidi = NULL;
322 }
323
324 static int __devinit emu10k1_midi_init(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, int device, char *name)
325 {
326         struct snd_rawmidi *rmidi;
327         int err;
328
329         if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0)
330                 return err;
331         midi->emu = emu;
332         spin_lock_init(&midi->open_lock);
333         spin_lock_init(&midi->input_lock);
334         spin_lock_init(&midi->output_lock);
335         strcpy(rmidi->name, name);
336         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_emu10k1_midi_output);
337         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_emu10k1_midi_input);
338         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
339                              SNDRV_RAWMIDI_INFO_INPUT |
340                              SNDRV_RAWMIDI_INFO_DUPLEX;
341         rmidi->private_data = midi;
342         rmidi->private_free = snd_emu10k1_midi_free;
343         midi->rmidi = rmidi;
344         return 0;
345 }
346
347 int __devinit snd_emu10k1_midi(struct snd_emu10k1 *emu)
348 {
349         struct snd_emu10k1_midi *midi = &emu->midi;
350         int err;
351
352         if ((err = emu10k1_midi_init(emu, midi, 0, "EMU10K1 MPU-401 (UART)")) < 0)
353                 return err;
354
355         midi->tx_enable = INTE_MIDITXENABLE;
356         midi->rx_enable = INTE_MIDIRXENABLE;
357         midi->port = MUDATA;
358         midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
359         midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
360         midi->interrupt = snd_emu10k1_midi_interrupt;
361         return 0;
362 }
363
364 int __devinit snd_emu10k1_audigy_midi(struct snd_emu10k1 *emu)
365 {
366         struct snd_emu10k1_midi *midi;
367         int err;
368
369         midi = &emu->midi;
370         if ((err = emu10k1_midi_init(emu, midi, 0, "Audigy MPU-401 (UART)")) < 0)
371                 return err;
372
373         midi->tx_enable = INTE_MIDITXENABLE;
374         midi->rx_enable = INTE_MIDIRXENABLE;
375         midi->port = A_MUDATA1;
376         midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
377         midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
378         midi->interrupt = snd_emu10k1_midi_interrupt;
379
380         midi = &emu->midi2;
381         if ((err = emu10k1_midi_init(emu, midi, 1, "Audigy MPU-401 #2")) < 0)
382                 return err;
383
384         midi->tx_enable = INTE_A_MIDITXENABLE2;
385         midi->rx_enable = INTE_A_MIDIRXENABLE2;
386         midi->port = A_MUDATA2;
387         midi->ipr_tx = IPR_A_MIDITRANSBUFEMPTY2;
388         midi->ipr_rx = IPR_A_MIDIRECVBUFEMPTY2;
389         midi->interrupt = snd_emu10k1_midi_interrupt2;
390         return 0;
391 }