Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * MOTU Midi Timepiece ALSA Main routines | |
3 | * Copyright by Michael T. Mayers (c) Jan 09, 2000 | |
4 | * mail: michael@tweakoz.com | |
5 | * Thanks to John Galbraith | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 | * | |
21 | * | |
22 | * This driver is for the 'Mark Of The Unicorn' (MOTU) | |
23 | * MidiTimePiece AV multiport MIDI interface | |
24 | * | |
25 | * IOPORTS | |
26 | * ------- | |
27 | * 8 MIDI Ins and 8 MIDI outs | |
28 | * Video Sync In (BNC), Word Sync Out (BNC), | |
29 | * ADAT Sync Out (DB9) | |
30 | * SMPTE in/out (1/4") | |
31 | * 2 programmable pedal/footswitch inputs and 4 programmable MIDI controller knobs. | |
32 | * Macintosh RS422 serial port | |
33 | * RS422 "network" port for ganging multiple MTP's | |
34 | * PC Parallel Port ( which this driver currently uses ) | |
35 | * | |
36 | * MISC FEATURES | |
37 | * ------------- | |
38 | * Hardware MIDI routing, merging, and filtering | |
39 | * MIDI Synchronization to Video, ADAT, SMPTE and other Clock sources | |
40 | * 128 'scene' memories, recallable from MIDI program change | |
41 | * | |
42 | * | |
43 | * ChangeLog | |
44 | * Jun 11 2001 Takashi Iwai <tiwai@suse.de> | |
45 | * - Recoded & debugged | |
46 | * - Added timer interrupt for midi outputs | |
47 | * - hwports is between 1 and 8, which specifies the number of hardware ports. | |
48 | * The three global ports, computer, adat and broadcast ports, are created | |
49 | * always after h/w and remote ports. | |
50 | * | |
51 | */ | |
52 | ||
53 | #include <sound/driver.h> | |
54 | #include <linux/init.h> | |
55 | #include <linux/interrupt.h> | |
56 | #include <linux/slab.h> | |
57 | #include <linux/ioport.h> | |
58 | #include <linux/moduleparam.h> | |
59 | #include <sound/core.h> | |
60 | #include <sound/initval.h> | |
61 | #include <sound/rawmidi.h> | |
62 | #include <linux/delay.h> | |
63 | ||
64 | #include <asm/io.h> | |
65 | ||
66 | /* | |
67 | * globals | |
68 | */ | |
69 | MODULE_AUTHOR("Michael T. Mayers"); | |
70 | MODULE_DESCRIPTION("MOTU MidiTimePiece AV multiport MIDI"); | |
71 | MODULE_LICENSE("GPL"); | |
72 | MODULE_SUPPORTED_DEVICE("{{MOTU,MidiTimePiece AV multiport MIDI}}"); | |
73 | ||
74 | // io resources | |
75 | #define MTPAV_IOBASE 0x378 | |
76 | #define MTPAV_IRQ 7 | |
77 | #define MTPAV_MAX_PORTS 8 | |
78 | ||
79 | static int index = SNDRV_DEFAULT_IDX1; | |
80 | static char *id = SNDRV_DEFAULT_STR1; | |
81 | static long port = MTPAV_IOBASE; /* 0x378, 0x278 */ | |
82 | static int irq = MTPAV_IRQ; /* 7, 5 */ | |
83 | static int hwports = MTPAV_MAX_PORTS; /* use hardware ports 1-8 */ | |
84 | ||
85 | module_param(index, int, 0444); | |
86 | MODULE_PARM_DESC(index, "Index value for MotuMTPAV MIDI."); | |
87 | module_param(id, charp, 0444); | |
88 | MODULE_PARM_DESC(id, "ID string for MotuMTPAV MIDI."); | |
89 | module_param(port, long, 0444); | |
90 | MODULE_PARM_DESC(port, "Parallel port # for MotuMTPAV MIDI."); | |
91 | module_param(irq, int, 0444); | |
92 | MODULE_PARM_DESC(irq, "Parallel IRQ # for MotuMTPAV MIDI."); | |
93 | module_param(hwports, int, 0444); | |
94 | MODULE_PARM_DESC(hwports, "Hardware ports # for MotuMTPAV MIDI."); | |
95 | ||
96 | /* | |
97 | * defines | |
98 | */ | |
99 | //#define USE_FAKE_MTP // don't actually read/write to MTP device (for debugging without an actual unit) (does not work yet) | |
100 | ||
101 | // parallel port usage masks | |
102 | #define SIGS_BYTE 0x08 | |
103 | #define SIGS_RFD 0x80 | |
104 | #define SIGS_IRQ 0x40 | |
105 | #define SIGS_IN0 0x10 | |
106 | #define SIGS_IN1 0x20 | |
107 | ||
108 | #define SIGC_WRITE 0x04 | |
109 | #define SIGC_READ 0x08 | |
110 | #define SIGC_INTEN 0x10 | |
111 | ||
112 | #define DREG 0 | |
113 | #define SREG 1 | |
114 | #define CREG 2 | |
115 | ||
116 | // | |
117 | #define MTPAV_MODE_INPUT_OPENED 0x01 | |
118 | #define MTPAV_MODE_OUTPUT_OPENED 0x02 | |
119 | #define MTPAV_MODE_INPUT_TRIGGERED 0x04 | |
120 | #define MTPAV_MODE_OUTPUT_TRIGGERED 0x08 | |
121 | ||
122 | #define NUMPORTS (0x12+1) | |
123 | ||
124 | ||
125 | /* | |
126 | */ | |
127 | ||
128 | typedef struct mtpav_port { | |
129 | u8 number; | |
130 | u8 hwport; | |
131 | u8 mode; | |
132 | u8 running_status; | |
133 | snd_rawmidi_substream_t *input; | |
134 | snd_rawmidi_substream_t *output; | |
135 | } mtpav_port_t; | |
136 | ||
137 | typedef struct mtpav { | |
138 | snd_card_t *card; | |
139 | unsigned long port; | |
140 | struct resource *res_port; | |
141 | int irq; /* interrupt (for inputs) */ | |
142 | spinlock_t spinlock; | |
143 | int share_irq; /* number of accesses to input interrupts */ | |
144 | int istimer; /* number of accesses to timer interrupts */ | |
145 | struct timer_list timer; /* timer interrupts for outputs */ | |
146 | snd_rawmidi_t *rmidi; | |
147 | int num_ports; /* number of hw ports (1-8) */ | |
148 | mtpav_port_t ports[NUMPORTS]; /* all ports including computer, adat and bc */ | |
149 | ||
150 | u32 inmidiport; /* selected input midi port */ | |
151 | u32 inmidistate; /* during midi command 0xf5 */ | |
152 | ||
153 | u32 outmidihwport; /* selected output midi hw port */ | |
154 | } mtpav_t; | |
155 | ||
156 | ||
157 | /* | |
158 | * global instance | |
159 | * hey, we handle at most only one card.. | |
160 | */ | |
161 | static mtpav_t *mtp_card; | |
162 | ||
163 | /* | |
164 | * possible hardware ports (selected by 0xf5 port message) | |
165 | * 0x00 all ports | |
166 | * 0x01 .. 0x08 this MTP's ports 1..8 | |
167 | * 0x09 .. 0x10 networked MTP's ports (9..16) | |
168 | * 0x11 networked MTP's computer port | |
169 | * 0x63 to ADAT | |
170 | * | |
171 | * mappig: | |
172 | * subdevice 0 - (X-1) ports | |
173 | * X - (2*X-1) networked ports | |
174 | * X computer | |
175 | * X+1 ADAT | |
176 | * X+2 all ports | |
177 | * | |
178 | * where X = chip->num_ports | |
179 | */ | |
180 | ||
181 | #define MTPAV_PIDX_COMPUTER 0 | |
182 | #define MTPAV_PIDX_ADAT 1 | |
183 | #define MTPAV_PIDX_BROADCAST 2 | |
184 | ||
185 | ||
186 | static int translate_subdevice_to_hwport(mtpav_t *chip, int subdev) | |
187 | { | |
188 | if (subdev < 0) | |
189 | return 0x01; /* invalid - use port 0 as default */ | |
190 | else if (subdev < chip->num_ports) | |
191 | return subdev + 1; /* single mtp port */ | |
192 | else if (subdev < chip->num_ports * 2) | |
193 | return subdev - chip->num_ports + 0x09; /* remote port */ | |
194 | else if (subdev == chip->num_ports * 2 + MTPAV_PIDX_COMPUTER) | |
195 | return 0x11; /* computer port */ | |
196 | else if (subdev == chip->num_ports + MTPAV_PIDX_ADAT) | |
197 | return 0x63; /* ADAT */ | |
198 | return 0; /* all ports */ | |
199 | } | |
200 | ||
201 | static int translate_hwport_to_subdevice(mtpav_t *chip, int hwport) | |
202 | { | |
203 | int p; | |
204 | if (hwport <= 0x00) /* all ports */ | |
205 | return chip->num_ports + MTPAV_PIDX_BROADCAST; | |
206 | else if (hwport <= 0x08) { /* single port */ | |
207 | p = hwport - 1; | |
208 | if (p >= chip->num_ports) | |
209 | p = 0; | |
210 | return p; | |
211 | } else if (hwport <= 0x10) { /* remote port */ | |
212 | p = hwport - 0x09 + chip->num_ports; | |
213 | if (p >= chip->num_ports * 2) | |
214 | p = chip->num_ports; | |
215 | return p; | |
216 | } else if (hwport == 0x11) /* computer port */ | |
217 | return chip->num_ports + MTPAV_PIDX_COMPUTER; | |
218 | else /* ADAT */ | |
219 | return chip->num_ports + MTPAV_PIDX_ADAT; | |
220 | } | |
221 | ||
222 | ||
223 | /* | |
224 | */ | |
225 | ||
226 | static u8 snd_mtpav_getreg(mtpav_t *chip, u16 reg) | |
227 | { | |
228 | u8 rval = 0; | |
229 | ||
230 | if (reg == SREG) { | |
231 | rval = inb(chip->port + SREG); | |
232 | rval = (rval & 0xf8); | |
233 | } else if (reg == CREG) { | |
234 | rval = inb(chip->port + CREG); | |
235 | rval = (rval & 0x1c); | |
236 | } | |
237 | ||
238 | return rval; | |
239 | } | |
240 | ||
241 | /* | |
242 | */ | |
243 | ||
244 | static void snd_mtpav_mputreg(mtpav_t *chip, u16 reg, u8 val) | |
245 | { | |
246 | if (reg == DREG) { | |
247 | outb(val, chip->port + DREG); | |
248 | } else if (reg == CREG) { | |
249 | outb(val, chip->port + CREG); | |
250 | } | |
251 | } | |
252 | ||
253 | /* | |
254 | */ | |
255 | ||
256 | static void snd_mtpav_wait_rfdhi(mtpav_t *chip) | |
257 | { | |
258 | int counts = 10000; | |
259 | u8 sbyte; | |
260 | ||
261 | sbyte = snd_mtpav_getreg(chip, SREG); | |
262 | while (!(sbyte & SIGS_RFD) && counts--) { | |
263 | sbyte = snd_mtpav_getreg(chip, SREG); | |
264 | udelay(10); | |
265 | } | |
266 | } | |
267 | ||
268 | static void snd_mtpav_send_byte(mtpav_t *chip, u8 byte) | |
269 | { | |
270 | u8 tcbyt; | |
271 | u8 clrwrite; | |
272 | u8 setwrite; | |
273 | ||
274 | snd_mtpav_wait_rfdhi(chip); | |
275 | ||
276 | ///////////////// | |
277 | ||
278 | tcbyt = snd_mtpav_getreg(chip, CREG); | |
279 | clrwrite = tcbyt & (SIGC_WRITE ^ 0xff); | |
280 | setwrite = tcbyt | SIGC_WRITE; | |
281 | ||
282 | snd_mtpav_mputreg(chip, DREG, byte); | |
283 | snd_mtpav_mputreg(chip, CREG, clrwrite); // clear write bit | |
284 | ||
285 | snd_mtpav_mputreg(chip, CREG, setwrite); // set write bit | |
286 | ||
287 | } | |
288 | ||
289 | ||
290 | /* | |
291 | */ | |
292 | ||
293 | /* call this with spin lock held */ | |
294 | static void snd_mtpav_output_port_write(mtpav_port_t *port, | |
295 | snd_rawmidi_substream_t *substream) | |
296 | { | |
297 | u8 outbyte; | |
298 | ||
299 | // Get the outbyte first, so we can emulate running status if | |
300 | // necessary | |
301 | if (snd_rawmidi_transmit(substream, &outbyte, 1) != 1) | |
302 | return; | |
303 | ||
304 | // send port change command if necessary | |
305 | ||
306 | if (port->hwport != mtp_card->outmidihwport) { | |
307 | mtp_card->outmidihwport = port->hwport; | |
308 | ||
309 | snd_mtpav_send_byte(mtp_card, 0xf5); | |
310 | snd_mtpav_send_byte(mtp_card, port->hwport); | |
311 | //snd_printk("new outport: 0x%x\n", (unsigned int) port->hwport); | |
312 | ||
313 | if (!(outbyte & 0x80) && port->running_status) | |
314 | snd_mtpav_send_byte(mtp_card, port->running_status); | |
315 | } | |
316 | ||
317 | // send data | |
318 | ||
319 | do { | |
320 | if (outbyte & 0x80) | |
321 | port->running_status = outbyte; | |
322 | ||
323 | snd_mtpav_send_byte(mtp_card, outbyte); | |
324 | } while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1); | |
325 | } | |
326 | ||
327 | static void snd_mtpav_output_write(snd_rawmidi_substream_t * substream) | |
328 | { | |
329 | mtpav_port_t *port = &mtp_card->ports[substream->number]; | |
330 | unsigned long flags; | |
331 | ||
332 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
333 | snd_mtpav_output_port_write(port, substream); | |
334 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
335 | } | |
336 | ||
337 | ||
338 | /* | |
339 | * mtpav control | |
340 | */ | |
341 | ||
342 | static void snd_mtpav_portscan(mtpav_t *chip) // put mtp into smart routing mode | |
343 | { | |
344 | u8 p; | |
345 | ||
346 | for (p = 0; p < 8; p++) { | |
347 | snd_mtpav_send_byte(chip, 0xf5); | |
348 | snd_mtpav_send_byte(chip, p); | |
349 | snd_mtpav_send_byte(chip, 0xfe); | |
350 | } | |
351 | } | |
352 | ||
353 | /* | |
354 | */ | |
355 | ||
356 | static int snd_mtpav_input_open(snd_rawmidi_substream_t * substream) | |
357 | { | |
358 | unsigned long flags; | |
359 | mtpav_port_t *portp = &mtp_card->ports[substream->number]; | |
360 | ||
361 | //printk("mtpav port: %d opened\n", (int) substream->number); | |
362 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
363 | portp->mode |= MTPAV_MODE_INPUT_OPENED; | |
364 | portp->input = substream; | |
365 | if (mtp_card->share_irq++ == 0) | |
366 | snd_mtpav_mputreg(mtp_card, CREG, (SIGC_INTEN | SIGC_WRITE)); // enable pport interrupts | |
367 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
368 | return 0; | |
369 | } | |
370 | ||
371 | /* | |
372 | */ | |
373 | ||
374 | static int snd_mtpav_input_close(snd_rawmidi_substream_t *substream) | |
375 | { | |
376 | unsigned long flags; | |
377 | mtpav_port_t *portp = &mtp_card->ports[substream->number]; | |
378 | ||
379 | //printk("mtpav port: %d closed\n", (int) portp); | |
380 | ||
381 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
382 | ||
383 | portp->mode &= (~MTPAV_MODE_INPUT_OPENED); | |
384 | portp->input = NULL; | |
385 | if (--mtp_card->share_irq == 0) | |
386 | snd_mtpav_mputreg(mtp_card, CREG, 0); // disable pport interrupts | |
387 | ||
388 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
389 | return 0; | |
390 | } | |
391 | ||
392 | /* | |
393 | */ | |
394 | ||
395 | static void snd_mtpav_input_trigger(snd_rawmidi_substream_t * substream, int up) | |
396 | { | |
397 | unsigned long flags; | |
398 | mtpav_port_t *portp = &mtp_card->ports[substream->number]; | |
399 | ||
400 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
401 | if (up) | |
402 | portp->mode |= MTPAV_MODE_INPUT_TRIGGERED; | |
403 | else | |
404 | portp->mode &= ~MTPAV_MODE_INPUT_TRIGGERED; | |
405 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
406 | ||
407 | } | |
408 | ||
409 | ||
410 | /* | |
411 | * timer interrupt for outputs | |
412 | */ | |
413 | ||
414 | static void snd_mtpav_output_timer(unsigned long data) | |
415 | { | |
416 | unsigned long flags; | |
417 | mtpav_t *chip = (mtpav_t *)data; | |
418 | int p; | |
419 | ||
420 | spin_lock_irqsave(&chip->spinlock, flags); | |
421 | /* reprogram timer */ | |
422 | chip->timer.expires = 1 + jiffies; | |
423 | add_timer(&chip->timer); | |
424 | /* process each port */ | |
425 | for (p = 0; p <= chip->num_ports * 2 + MTPAV_PIDX_BROADCAST; p++) { | |
426 | mtpav_port_t *portp = &mtp_card->ports[p]; | |
427 | if ((portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && portp->output) | |
428 | snd_mtpav_output_port_write(portp, portp->output); | |
429 | } | |
430 | spin_unlock_irqrestore(&chip->spinlock, flags); | |
431 | } | |
432 | ||
433 | /* spinlock held! */ | |
434 | static void snd_mtpav_add_output_timer(mtpav_t *chip) | |
435 | { | |
436 | init_timer(&chip->timer); | |
437 | chip->timer.function = snd_mtpav_output_timer; | |
438 | chip->timer.data = (unsigned long) mtp_card; | |
439 | chip->timer.expires = 1 + jiffies; | |
440 | add_timer(&chip->timer); | |
441 | } | |
442 | ||
443 | /* spinlock held! */ | |
444 | static void snd_mtpav_remove_output_timer(mtpav_t *chip) | |
445 | { | |
446 | del_timer(&chip->timer); | |
447 | } | |
448 | ||
449 | /* | |
450 | */ | |
451 | ||
452 | static int snd_mtpav_output_open(snd_rawmidi_substream_t * substream) | |
453 | { | |
454 | unsigned long flags; | |
455 | mtpav_port_t *portp = &mtp_card->ports[substream->number]; | |
456 | ||
457 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
458 | portp->mode |= MTPAV_MODE_OUTPUT_OPENED; | |
459 | portp->output = substream; | |
460 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
461 | return 0; | |
462 | }; | |
463 | ||
464 | /* | |
465 | */ | |
466 | ||
467 | static int snd_mtpav_output_close(snd_rawmidi_substream_t * substream) | |
468 | { | |
469 | unsigned long flags; | |
470 | mtpav_port_t *portp = &mtp_card->ports[substream->number]; | |
471 | ||
472 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
473 | portp->mode &= (~MTPAV_MODE_OUTPUT_OPENED); | |
474 | portp->output = NULL; | |
475 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
476 | return 0; | |
477 | }; | |
478 | ||
479 | /* | |
480 | */ | |
481 | ||
482 | static void snd_mtpav_output_trigger(snd_rawmidi_substream_t * substream, int up) | |
483 | { | |
484 | unsigned long flags; | |
485 | mtpav_port_t *portp = &mtp_card->ports[substream->number]; | |
486 | ||
487 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
488 | if (up) { | |
489 | if (! (portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED)) { | |
490 | if (mtp_card->istimer++ == 0) | |
491 | snd_mtpav_add_output_timer(mtp_card); | |
492 | portp->mode |= MTPAV_MODE_OUTPUT_TRIGGERED; | |
493 | } | |
494 | } else { | |
495 | portp->mode &= ~MTPAV_MODE_OUTPUT_TRIGGERED; | |
496 | if (--mtp_card->istimer == 0) | |
497 | snd_mtpav_remove_output_timer(mtp_card); | |
498 | } | |
499 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
500 | ||
501 | if (up) | |
502 | snd_mtpav_output_write(substream); | |
503 | } | |
504 | ||
505 | /* | |
506 | * midi interrupt for inputs | |
507 | */ | |
508 | ||
509 | static void snd_mtpav_inmidi_process(mtpav_t *mcrd, u8 inbyte) | |
510 | { | |
511 | mtpav_port_t *portp; | |
512 | ||
513 | if ((int)mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST) | |
514 | return; | |
515 | ||
516 | portp = &mcrd->ports[mcrd->inmidiport]; | |
517 | if (portp->mode & MTPAV_MODE_INPUT_TRIGGERED) { | |
518 | snd_rawmidi_receive(portp->input, &inbyte, 1); | |
519 | } | |
520 | } | |
521 | ||
522 | static void snd_mtpav_inmidi_h(mtpav_t * mcrd, u8 inbyte) | |
523 | { | |
524 | snd_assert(mcrd, return); | |
525 | ||
526 | if (inbyte >= 0xf8) { | |
527 | /* real-time midi code */ | |
528 | snd_mtpav_inmidi_process(mcrd, inbyte); | |
529 | return; | |
530 | } | |
531 | ||
532 | if (mcrd->inmidistate == 0) { // awaiting command | |
533 | if (inbyte == 0xf5) // MTP port # | |
534 | mcrd->inmidistate = 1; | |
535 | else | |
536 | snd_mtpav_inmidi_process(mcrd, inbyte); | |
537 | } else if (mcrd->inmidistate) { | |
538 | mcrd->inmidiport = translate_hwport_to_subdevice(mcrd, inbyte); | |
539 | mcrd->inmidistate = 0; | |
540 | } | |
541 | } | |
542 | ||
543 | static void snd_mtpav_read_bytes(mtpav_t * mcrd) | |
544 | { | |
545 | u8 clrread, setread; | |
546 | u8 mtp_read_byte; | |
547 | u8 sr, cbyt; | |
548 | int i; | |
549 | ||
550 | u8 sbyt = snd_mtpav_getreg(mcrd, SREG); | |
551 | ||
552 | //printk("snd_mtpav_read_bytes() sbyt: 0x%x\n", sbyt); | |
553 | ||
554 | if (!(sbyt & SIGS_BYTE)) | |
555 | return; | |
556 | ||
557 | cbyt = snd_mtpav_getreg(mcrd, CREG); | |
558 | clrread = cbyt & (SIGC_READ ^ 0xff); | |
559 | setread = cbyt | SIGC_READ; | |
560 | ||
561 | do { | |
562 | ||
563 | mtp_read_byte = 0; | |
564 | for (i = 0; i < 4; i++) { | |
565 | snd_mtpav_mputreg(mcrd, CREG, setread); | |
566 | sr = snd_mtpav_getreg(mcrd, SREG); | |
567 | snd_mtpav_mputreg(mcrd, CREG, clrread); | |
568 | ||
569 | sr &= SIGS_IN0 | SIGS_IN1; | |
570 | sr >>= 4; | |
571 | mtp_read_byte |= sr << (i * 2); | |
572 | } | |
573 | ||
574 | snd_mtpav_inmidi_h(mcrd, mtp_read_byte); | |
575 | ||
576 | sbyt = snd_mtpav_getreg(mcrd, SREG); | |
577 | ||
578 | } while (sbyt & SIGS_BYTE); | |
579 | } | |
580 | ||
581 | static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs) | |
582 | { | |
583 | mtpav_t *mcard = dev_id; | |
584 | ||
585 | //printk("irqh()\n"); | |
586 | spin_lock(&mcard->spinlock); | |
587 | snd_mtpav_read_bytes(mcard); | |
588 | spin_unlock(&mcard->spinlock); | |
589 | return IRQ_HANDLED; | |
590 | } | |
591 | ||
592 | /* | |
593 | * get ISA resources | |
594 | */ | |
595 | static int snd_mtpav_get_ISA(mtpav_t * mcard) | |
596 | { | |
597 | if ((mcard->res_port = request_region(port, 3, "MotuMTPAV MIDI")) == NULL) { | |
598 | snd_printk("MTVAP port 0x%lx is busy\n", port); | |
599 | return -EBUSY; | |
600 | } | |
601 | mcard->port = port; | |
602 | if (request_irq(irq, snd_mtpav_irqh, SA_INTERRUPT, "MOTU MTPAV", (void *)mcard)) { | |
603 | snd_printk("MTVAP IRQ %d busy\n", irq); | |
604 | return -EBUSY; | |
605 | } | |
606 | mcard->irq = irq; | |
607 | return 0; | |
608 | } | |
609 | ||
610 | ||
611 | /* | |
612 | */ | |
613 | ||
614 | static snd_rawmidi_ops_t snd_mtpav_output = { | |
615 | .open = snd_mtpav_output_open, | |
616 | .close = snd_mtpav_output_close, | |
617 | .trigger = snd_mtpav_output_trigger, | |
618 | }; | |
619 | ||
620 | static snd_rawmidi_ops_t snd_mtpav_input = { | |
621 | .open = snd_mtpav_input_open, | |
622 | .close = snd_mtpav_input_close, | |
623 | .trigger = snd_mtpav_input_trigger, | |
624 | }; | |
625 | ||
626 | ||
627 | /* | |
628 | * get RAWMIDI resources | |
629 | */ | |
630 | ||
631 | static void snd_mtpav_set_name(mtpav_t *chip, snd_rawmidi_substream_t *substream) | |
632 | { | |
633 | if (substream->number >= 0 && substream->number < chip->num_ports) | |
634 | sprintf(substream->name, "MTP direct %d", (substream->number % chip->num_ports) + 1); | |
635 | else if (substream->number >= 8 && substream->number < chip->num_ports * 2) | |
636 | sprintf(substream->name, "MTP remote %d", (substream->number % chip->num_ports) + 1); | |
637 | else if (substream->number == chip->num_ports * 2) | |
638 | strcpy(substream->name, "MTP computer"); | |
639 | else if (substream->number == chip->num_ports * 2 + 1) | |
640 | strcpy(substream->name, "MTP ADAT"); | |
641 | else | |
642 | strcpy(substream->name, "MTP broadcast"); | |
643 | } | |
644 | ||
645 | static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard) | |
646 | { | |
647 | int rval = 0; | |
648 | snd_rawmidi_t *rawmidi; | |
649 | snd_rawmidi_substream_t *substream; | |
650 | struct list_head *list; | |
651 | ||
652 | //printk("entering snd_mtpav_get_RAWMIDI\n"); | |
653 | ||
654 | if (hwports < 1) | |
655 | mcard->num_ports = 1; | |
656 | else if (hwports > 8) | |
657 | mcard->num_ports = 8; | |
658 | else | |
659 | mcard->num_ports = hwports; | |
660 | ||
661 | if ((rval = snd_rawmidi_new(mcard->card, "MotuMIDI", 0, | |
662 | mcard->num_ports * 2 + MTPAV_PIDX_BROADCAST + 1, | |
663 | mcard->num_ports * 2 + MTPAV_PIDX_BROADCAST + 1, | |
664 | &mcard->rmidi)) < 0) | |
665 | return rval; | |
666 | rawmidi = mcard->rmidi; | |
667 | ||
668 | list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { | |
669 | substream = list_entry(list, snd_rawmidi_substream_t, list); | |
670 | snd_mtpav_set_name(mcard, substream); | |
671 | substream->ops = &snd_mtpav_input; | |
672 | } | |
673 | list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { | |
674 | substream = list_entry(list, snd_rawmidi_substream_t, list); | |
675 | snd_mtpav_set_name(mcard, substream); | |
676 | substream->ops = &snd_mtpav_output; | |
677 | mcard->ports[substream->number].hwport = translate_subdevice_to_hwport(mcard, substream->number); | |
678 | } | |
679 | rawmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | | |
680 | SNDRV_RAWMIDI_INFO_DUPLEX; | |
681 | sprintf(rawmidi->name, "MTP AV MIDI"); | |
682 | //printk("exiting snd_mtpav_get_RAWMIDI() \n"); | |
683 | return 0; | |
684 | } | |
685 | ||
686 | /* | |
687 | */ | |
688 | ||
689 | static mtpav_t *new_mtpav(void) | |
690 | { | |
691 | mtpav_t *ncrd = kcalloc(1, sizeof(*ncrd), GFP_KERNEL); | |
692 | if (ncrd != NULL) { | |
693 | spin_lock_init(&ncrd->spinlock); | |
694 | ||
695 | init_timer(&ncrd->timer); | |
696 | ncrd->card = NULL; | |
697 | ncrd->irq = -1; | |
698 | ncrd->share_irq = 0; | |
699 | ||
700 | ncrd->inmidiport = 0xffffffff; | |
701 | ncrd->inmidistate = 0; | |
702 | ncrd->outmidihwport = 0xffffffff; | |
703 | } | |
704 | return ncrd; | |
705 | } | |
706 | ||
707 | /* | |
708 | */ | |
709 | ||
710 | static void free_mtpav(mtpav_t * crd) | |
711 | { | |
712 | unsigned long flags; | |
713 | ||
714 | spin_lock_irqsave(&crd->spinlock, flags); | |
715 | if (crd->istimer > 0) | |
716 | snd_mtpav_remove_output_timer(crd); | |
717 | spin_unlock_irqrestore(&crd->spinlock, flags); | |
718 | if (crd->irq >= 0) | |
719 | free_irq(crd->irq, (void *)crd); | |
720 | if (crd->res_port) { | |
721 | release_resource(crd->res_port); | |
722 | kfree_nocheck(crd->res_port); | |
723 | } | |
724 | kfree(crd); | |
725 | } | |
726 | ||
727 | /* | |
728 | */ | |
729 | ||
730 | static int __init alsa_card_mtpav_init(void) | |
731 | { | |
732 | int err = 0; | |
733 | char longname_buffer[80]; | |
734 | ||
735 | mtp_card = new_mtpav(); | |
736 | if (mtp_card == NULL) | |
737 | return -ENOMEM; | |
738 | ||
739 | mtp_card->card = snd_card_new(index, id, THIS_MODULE, 0); | |
740 | if (mtp_card->card == NULL) { | |
741 | free_mtpav(mtp_card); | |
742 | return -ENOMEM; | |
743 | } | |
744 | ||
745 | err = snd_mtpav_get_ISA(mtp_card); | |
746 | //printk("snd_mtpav_get_ISA returned: %d\n", err); | |
747 | if (err < 0) | |
748 | goto __error; | |
749 | ||
750 | strcpy(mtp_card->card->driver, "MTPAV"); | |
751 | strcpy(mtp_card->card->shortname, "MTPAV on parallel port"); | |
752 | memset(longname_buffer, 0, sizeof(longname_buffer)); | |
753 | sprintf(longname_buffer, "MTPAV on parallel port at"); | |
754 | ||
755 | err = snd_mtpav_get_RAWMIDI(mtp_card); | |
756 | //snd_printk("snd_mtapv_get_RAWMIDI returned: %d\n", err); | |
757 | if (err < 0) | |
758 | goto __error; | |
759 | ||
760 | err = snd_card_register(mtp_card->card); // don't snd_card_register until AFTER all cards reources done! | |
761 | ||
762 | //printk("snd_card_register returned %d\n", err); | |
763 | if (err < 0) | |
764 | goto __error; | |
765 | ||
766 | ||
767 | snd_mtpav_portscan(mtp_card); | |
768 | ||
769 | printk(KERN_INFO "Motu MidiTimePiece on parallel port irq: %d ioport: 0x%lx\n", irq, port); | |
770 | ||
771 | return 0; | |
772 | ||
773 | __error: | |
774 | snd_card_free(mtp_card->card); | |
775 | free_mtpav(mtp_card); | |
776 | return err; | |
777 | } | |
778 | ||
779 | /* | |
780 | */ | |
781 | ||
782 | static void __exit alsa_card_mtpav_exit(void) | |
783 | { | |
784 | if (mtp_card == NULL) | |
785 | return; | |
786 | if (mtp_card->card) | |
787 | snd_card_free(mtp_card->card); | |
788 | free_mtpav(mtp_card); | |
789 | } | |
790 | ||
791 | /* | |
792 | */ | |
793 | ||
794 | module_init(alsa_card_mtpav_init) | |
795 | module_exit(alsa_card_mtpav_exit) |