?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC66 3.0.0.4.374.130 core
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / sound / pci / emu10k1 / emumpu401.c
blob950c6bcd6b7d9945775cfdefb9bfb9958ca56d5c
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 #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 }
Tomato firmware and modifications.