source: GPL/alsa-kernel/pci/emu10k1/emumpu401.c@ 18

Last change on this file since 18 was 18, checked in by vladest, 20 years ago

initial import
File size: 11.4 KB
Line 
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.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#define __NO_VERSION__
23#include <sound/driver.h>
24#include <linux/time.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
31static inline unsigned char mpu401_read(emu10k1_t *emu, emu10k1_midi_t *mpu, int idx)
32{
33 if (emu->audigy)
34 return (unsigned char)snd_emu10k1_ptr_read(emu, mpu->port + idx, 0);
35 else
36 return inb(emu->port + mpu->port + idx);
37}
38
39static inline void mpu401_write(emu10k1_t *emu, emu10k1_midi_t *mpu, int data, int idx)
40{
41 if (emu->audigy)
42 snd_emu10k1_ptr_write(emu, mpu->port + idx, 0, data);
43 else
44 outb(data, emu->port + mpu->port + idx);
45}
46
47#define mpu401_write_data(emu, mpu, data) mpu401_write(emu, mpu, data, 0)
48#define mpu401_write_cmd(emu, mpu, data) mpu401_write(emu, mpu, data, 1)
49#define mpu401_read_data(emu, mpu) mpu401_read(emu, mpu, 0)
50#define mpu401_read_stat(emu, mpu) mpu401_read(emu, mpu, 1)
51
52#define mpu401_input_avail(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x80))
53#define mpu401_output_ready(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x40))
54
55#define MPU401_RESET 0xff
56#define MPU401_ENTER_UART 0x3f
57#define MPU401_ACK 0xfe
58
59static void mpu401_clear_rx(emu10k1_t *emu, emu10k1_midi_t *mpu)
60{
61 int timeout = 100000;
62 for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--)
63 mpu401_read_data(emu, mpu);
64#ifdef CONFIG_SND_DEBUG
65 if (timeout <= 0)
66 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
67#endif
68}
69
70/*
71
72 */
73
74static void do_emu10k1_midi_interrupt(emu10k1_t *emu, emu10k1_midi_t *midi, unsigned int status)
75{
76 unsigned char byte;
77
78 if (midi->rmidi == NULL) {
79 snd_emu10k1_intr_disable(emu, midi->tx_enable | midi->rx_enable);
80 return;
81 }
82
83 spin_lock(&midi->input_lock);
84 if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
85 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
86 mpu401_clear_rx(emu, midi);
87 } else {
88 byte = mpu401_read_data(emu, midi);
89 spin_unlock(&midi->input_lock);
90 if (midi->substream_input)
91 snd_rawmidi_receive(midi->substream_input, &byte, 1);
92 spin_lock(&midi->input_lock);
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
109static void snd_emu10k1_midi_interrupt(emu10k1_t *emu, unsigned int status)
110{
111 do_emu10k1_midi_interrupt(emu, &emu->midi, status);
112}
113
114static void snd_emu10k1_midi_interrupt2(emu10k1_t *emu, unsigned int status)
115{
116 do_emu10k1_midi_interrupt(emu, &emu->midi2, status);
117}
118
119static void snd_emu10k1_midi_cmd(emu10k1_t * emu, emu10k1_midi_t *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}
150
151static int snd_emu10k1_midi_input_open(snd_rawmidi_substream_t * substream)
152{
153 emu10k1_t *emu;
154 emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data;
155 unsigned long flags;
156
157 emu = midi->emu;
158 snd_assert(emu, return -ENXIO);
159 spin_lock_irqsave(&midi->open_lock, flags);
160 midi->midi_mode |= EMU10K1_MIDI_MODE_INPUT;
161 midi->substream_input = substream;
162 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
163 spin_unlock_irqrestore(&midi->open_lock, flags);
164 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1);
165 snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1);
166 } else {
167 spin_unlock_irqrestore(&midi->open_lock, flags);
168 }
169 return 0;
170}
171
172static int snd_emu10k1_midi_output_open(snd_rawmidi_substream_t * substream)
173{
174 emu10k1_t *emu;
175 emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data;
176 unsigned long flags;
177
178 emu = midi->emu;
179 snd_assert(emu, return -ENXIO);
180 spin_lock_irqsave(&midi->open_lock, flags);
181 midi->midi_mode |= EMU10K1_MIDI_MODE_OUTPUT;
182 midi->substream_output = substream;
183 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
184 spin_unlock_irqrestore(&midi->open_lock, flags);
185 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1);
186 snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1);
187 } else {
188 spin_unlock_irqrestore(&midi->open_lock, flags);
189 }
190 return 0;
191}
192
193static int snd_emu10k1_midi_input_close(snd_rawmidi_substream_t * substream)
194{
195 emu10k1_t *emu;
196 emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data;
197 unsigned long flags;
198
199 emu = midi->emu;
200 snd_assert(emu, return -ENXIO);
201 spin_lock_irqsave(&midi->open_lock, flags);
202 snd_emu10k1_intr_disable(emu, midi->rx_enable);
203 midi->midi_mode &= ~EMU10K1_MIDI_MODE_INPUT;
204 midi->substream_input = NULL;
205 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
206 spin_unlock_irqrestore(&midi->open_lock, flags);
207 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
208 } else {
209 spin_unlock_irqrestore(&midi->open_lock, flags);
210 }
211 return 0;
212}
213
214static int snd_emu10k1_midi_output_close(snd_rawmidi_substream_t * substream)
215{
216 emu10k1_t *emu;
217 emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data;
218 unsigned long flags;
219
220 emu = midi->emu;
221 snd_assert(emu, return -ENXIO);
222 spin_lock_irqsave(&midi->open_lock, flags);
223 snd_emu10k1_intr_disable(emu, midi->tx_enable);
224 midi->midi_mode &= ~EMU10K1_MIDI_MODE_OUTPUT;
225 midi->substream_output = NULL;
226 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
227 spin_unlock_irqrestore(&midi->open_lock, flags);
228 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
229 } else {
230 spin_unlock_irqrestore(&midi->open_lock, flags);
231 }
232 return 0;
233}
234
235static void snd_emu10k1_midi_input_trigger(snd_rawmidi_substream_t * substream, int up)
236{
237 emu10k1_t *emu;
238 emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data;
239 emu = midi->emu;
240 snd_assert(emu, return);
241
242 if (up)
243 snd_emu10k1_intr_enable(emu, midi->rx_enable);
244 else
245 snd_emu10k1_intr_disable(emu, midi->rx_enable);
246}
247
248static void snd_emu10k1_midi_output_trigger(snd_rawmidi_substream_t * substream, int up)
249{
250 emu10k1_t *emu;
251 emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data;
252 unsigned long flags;
253
254 emu = midi->emu;
255 snd_assert(emu, return);
256
257 if (up) {
258 int max = 4;
259 unsigned char byte;
260
261 /* try to send some amount of bytes here before interrupts */
262 spin_lock_irqsave(&midi->output_lock, flags);
263 while (max > 0) {
264 if (mpu401_output_ready(emu, midi)) {
265 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT) ||
266 snd_rawmidi_transmit(substream, &byte, 1) != 1) {
267 /* no more data */
268 spin_unlock_irqrestore(&midi->output_lock, flags);
269 return;
270 }
271 mpu401_write_data(emu, midi, byte);
272 max--;
273 } else {
274 break;
275 }
276 }
277 spin_unlock_irqrestore(&midi->output_lock, flags);
278 snd_emu10k1_intr_enable(emu, midi->tx_enable);
279 } else {
280 snd_emu10k1_intr_disable(emu, midi->tx_enable);
281 }
282}
283
284/*
285
286 */
287
288#ifdef TARGET_OS2
289static snd_rawmidi_ops_t snd_emu10k1_midi_output =
290{
291 snd_emu10k1_midi_output_open,
292 snd_emu10k1_midi_output_close,
293 snd_emu10k1_midi_output_trigger,0
294};
295
296static snd_rawmidi_ops_t snd_emu10k1_midi_input =
297{
298 snd_emu10k1_midi_input_open,
299 snd_emu10k1_midi_input_close,
300 snd_emu10k1_midi_input_trigger,0
301};
302#else
303static snd_rawmidi_ops_t 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
310static snd_rawmidi_ops_t 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#endif
317
318static void snd_emu10k1_midi_free(snd_rawmidi_t *rmidi)
319{
320 emu10k1_midi_t *midi = (emu10k1_midi_t *)rmidi->private_data;
321 midi->interrupt = NULL;
322 midi->rmidi = NULL;
323}
324
325static int __devinit emu10k1_midi_init(emu10k1_t *emu, emu10k1_midi_t *midi, int device, char *name)
326{
327 snd_rawmidi_t *rmidi;
328 int err;
329
330 if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0)
331 return err;
332 midi->emu = emu;
333 spin_lock_init(&midi->open_lock);
334 spin_lock_init(&midi->input_lock);
335 spin_lock_init(&midi->output_lock);
336 strcpy(rmidi->name, name);
337 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_emu10k1_midi_output);
338 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_emu10k1_midi_input);
339 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
340 SNDRV_RAWMIDI_INFO_INPUT |
341 SNDRV_RAWMIDI_INFO_DUPLEX;
342 rmidi->private_data = midi;
343 rmidi->private_free = snd_emu10k1_midi_free;
344 midi->rmidi = rmidi;
345 return 0;
346}
347
348int __devinit snd_emu10k1_midi(emu10k1_t *emu)
349{
350 emu10k1_midi_t *midi = &emu->midi;
351 int err;
352
353 if ((err = emu10k1_midi_init(emu, midi, 0, "EMU10K1 MPU-401 (UART)")) < 0)
354 return err;
355
356 midi->tx_enable = INTE_MIDITXENABLE;
357 midi->rx_enable = INTE_MIDIRXENABLE;
358 midi->port = MUDATA;
359 midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
360 midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
361 midi->interrupt = snd_emu10k1_midi_interrupt;
362 return 0;
363}
364
365int __devinit snd_emu10k1_audigy_midi(emu10k1_t *emu)
366{
367 emu10k1_midi_t *midi;
368 int err;
369
370 midi = &emu->midi;
371 if ((err = emu10k1_midi_init(emu, midi, 0, "Audigy MPU-401 (UART)")) < 0)
372 return err;
373
374 midi->tx_enable = INTE_MIDITXENABLE;
375 midi->rx_enable = INTE_MIDIRXENABLE;
376 midi->port = A_MUDATA1;
377 midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
378 midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
379 midi->interrupt = snd_emu10k1_midi_interrupt;
380
381 midi = &emu->midi2;
382 if ((err = emu10k1_midi_init(emu, midi, 1, "Audigy MPU-401 #2")) < 0)
383 return err;
384
385 midi->tx_enable = INTE_A_MIDITXENABLE2;
386 midi->rx_enable = INTE_A_MIDIRXENABLE2;
387 midi->port = A_MUDATA2;
388 midi->ipr_tx = IPR_A_MIDITRANSBUFEMPTY2;
389 midi->ipr_rx = IPR_A_MIDIRECVBUFEMPTY2;
390 midi->interrupt = snd_emu10k1_midi_interrupt2;
391 return 0;
392}
Note: See TracBrowser for help on using the repository browser.