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 | ||
1da177e4 LT |
53 | #include <linux/init.h> |
54 | #include <linux/interrupt.h> | |
da155d5b | 55 | #include <linux/module.h> |
077d0ac5 TI |
56 | #include <linux/err.h> |
57 | #include <linux/platform_device.h> | |
1da177e4 | 58 | #include <linux/ioport.h> |
ddfb3199 | 59 | #include <linux/io.h> |
1da177e4 LT |
60 | #include <linux/moduleparam.h> |
61 | #include <sound/core.h> | |
62 | #include <sound/initval.h> | |
63 | #include <sound/rawmidi.h> | |
64 | #include <linux/delay.h> | |
65 | ||
1da177e4 LT |
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 | ||
f7a9275d CL |
96 | static struct platform_device *device; |
97 | ||
1da177e4 LT |
98 | /* |
99 | * defines | |
100 | */ | |
101 | //#define USE_FAKE_MTP // don't actually read/write to MTP device (for debugging without an actual unit) (does not work yet) | |
102 | ||
103 | // parallel port usage masks | |
104 | #define SIGS_BYTE 0x08 | |
105 | #define SIGS_RFD 0x80 | |
106 | #define SIGS_IRQ 0x40 | |
107 | #define SIGS_IN0 0x10 | |
108 | #define SIGS_IN1 0x20 | |
109 | ||
110 | #define SIGC_WRITE 0x04 | |
111 | #define SIGC_READ 0x08 | |
112 | #define SIGC_INTEN 0x10 | |
113 | ||
114 | #define DREG 0 | |
115 | #define SREG 1 | |
116 | #define CREG 2 | |
117 | ||
118 | // | |
119 | #define MTPAV_MODE_INPUT_OPENED 0x01 | |
120 | #define MTPAV_MODE_OUTPUT_OPENED 0x02 | |
121 | #define MTPAV_MODE_INPUT_TRIGGERED 0x04 | |
122 | #define MTPAV_MODE_OUTPUT_TRIGGERED 0x08 | |
123 | ||
124 | #define NUMPORTS (0x12+1) | |
125 | ||
126 | ||
127 | /* | |
128 | */ | |
129 | ||
077d0ac5 | 130 | struct mtpav_port { |
1da177e4 LT |
131 | u8 number; |
132 | u8 hwport; | |
133 | u8 mode; | |
134 | u8 running_status; | |
4a4d2cfd TI |
135 | struct snd_rawmidi_substream *input; |
136 | struct snd_rawmidi_substream *output; | |
077d0ac5 | 137 | }; |
1da177e4 | 138 | |
077d0ac5 | 139 | struct mtpav { |
4a4d2cfd | 140 | struct snd_card *card; |
1da177e4 LT |
141 | unsigned long port; |
142 | struct resource *res_port; | |
143 | int irq; /* interrupt (for inputs) */ | |
144 | spinlock_t spinlock; | |
145 | int share_irq; /* number of accesses to input interrupts */ | |
146 | int istimer; /* number of accesses to timer interrupts */ | |
147 | struct timer_list timer; /* timer interrupts for outputs */ | |
4a4d2cfd | 148 | struct snd_rawmidi *rmidi; |
1da177e4 | 149 | int num_ports; /* number of hw ports (1-8) */ |
077d0ac5 | 150 | struct mtpav_port ports[NUMPORTS]; /* all ports including computer, adat and bc */ |
1da177e4 LT |
151 | |
152 | u32 inmidiport; /* selected input midi port */ | |
153 | u32 inmidistate; /* during midi command 0xf5 */ | |
154 | ||
155 | u32 outmidihwport; /* selected output midi hw port */ | |
077d0ac5 | 156 | }; |
1da177e4 LT |
157 | |
158 | ||
1da177e4 LT |
159 | /* |
160 | * possible hardware ports (selected by 0xf5 port message) | |
161 | * 0x00 all ports | |
162 | * 0x01 .. 0x08 this MTP's ports 1..8 | |
163 | * 0x09 .. 0x10 networked MTP's ports (9..16) | |
164 | * 0x11 networked MTP's computer port | |
165 | * 0x63 to ADAT | |
166 | * | |
167 | * mappig: | |
168 | * subdevice 0 - (X-1) ports | |
169 | * X - (2*X-1) networked ports | |
170 | * X computer | |
171 | * X+1 ADAT | |
172 | * X+2 all ports | |
173 | * | |
174 | * where X = chip->num_ports | |
175 | */ | |
176 | ||
177 | #define MTPAV_PIDX_COMPUTER 0 | |
178 | #define MTPAV_PIDX_ADAT 1 | |
179 | #define MTPAV_PIDX_BROADCAST 2 | |
180 | ||
181 | ||
077d0ac5 | 182 | static int translate_subdevice_to_hwport(struct mtpav *chip, int subdev) |
1da177e4 LT |
183 | { |
184 | if (subdev < 0) | |
185 | return 0x01; /* invalid - use port 0 as default */ | |
186 | else if (subdev < chip->num_ports) | |
187 | return subdev + 1; /* single mtp port */ | |
188 | else if (subdev < chip->num_ports * 2) | |
189 | return subdev - chip->num_ports + 0x09; /* remote port */ | |
190 | else if (subdev == chip->num_ports * 2 + MTPAV_PIDX_COMPUTER) | |
191 | return 0x11; /* computer port */ | |
192 | else if (subdev == chip->num_ports + MTPAV_PIDX_ADAT) | |
193 | return 0x63; /* ADAT */ | |
194 | return 0; /* all ports */ | |
195 | } | |
196 | ||
077d0ac5 | 197 | static int translate_hwport_to_subdevice(struct mtpav *chip, int hwport) |
1da177e4 LT |
198 | { |
199 | int p; | |
200 | if (hwport <= 0x00) /* all ports */ | |
201 | return chip->num_ports + MTPAV_PIDX_BROADCAST; | |
202 | else if (hwport <= 0x08) { /* single port */ | |
203 | p = hwport - 1; | |
204 | if (p >= chip->num_ports) | |
205 | p = 0; | |
206 | return p; | |
207 | } else if (hwport <= 0x10) { /* remote port */ | |
208 | p = hwport - 0x09 + chip->num_ports; | |
209 | if (p >= chip->num_ports * 2) | |
210 | p = chip->num_ports; | |
211 | return p; | |
212 | } else if (hwport == 0x11) /* computer port */ | |
213 | return chip->num_ports + MTPAV_PIDX_COMPUTER; | |
214 | else /* ADAT */ | |
215 | return chip->num_ports + MTPAV_PIDX_ADAT; | |
216 | } | |
217 | ||
218 | ||
219 | /* | |
220 | */ | |
221 | ||
077d0ac5 | 222 | static u8 snd_mtpav_getreg(struct mtpav *chip, u16 reg) |
1da177e4 LT |
223 | { |
224 | u8 rval = 0; | |
225 | ||
226 | if (reg == SREG) { | |
227 | rval = inb(chip->port + SREG); | |
228 | rval = (rval & 0xf8); | |
229 | } else if (reg == CREG) { | |
230 | rval = inb(chip->port + CREG); | |
231 | rval = (rval & 0x1c); | |
232 | } | |
233 | ||
234 | return rval; | |
235 | } | |
236 | ||
237 | /* | |
238 | */ | |
239 | ||
077d0ac5 | 240 | static inline void snd_mtpav_mputreg(struct mtpav *chip, u16 reg, u8 val) |
1da177e4 | 241 | { |
077d0ac5 TI |
242 | if (reg == DREG || reg == CREG) |
243 | outb(val, chip->port + reg); | |
1da177e4 LT |
244 | } |
245 | ||
246 | /* | |
247 | */ | |
248 | ||
077d0ac5 | 249 | static void snd_mtpav_wait_rfdhi(struct mtpav *chip) |
1da177e4 LT |
250 | { |
251 | int counts = 10000; | |
252 | u8 sbyte; | |
253 | ||
254 | sbyte = snd_mtpav_getreg(chip, SREG); | |
255 | while (!(sbyte & SIGS_RFD) && counts--) { | |
256 | sbyte = snd_mtpav_getreg(chip, SREG); | |
257 | udelay(10); | |
258 | } | |
259 | } | |
260 | ||
077d0ac5 | 261 | static void snd_mtpav_send_byte(struct mtpav *chip, u8 byte) |
1da177e4 LT |
262 | { |
263 | u8 tcbyt; | |
264 | u8 clrwrite; | |
265 | u8 setwrite; | |
266 | ||
267 | snd_mtpav_wait_rfdhi(chip); | |
268 | ||
269 | ///////////////// | |
270 | ||
271 | tcbyt = snd_mtpav_getreg(chip, CREG); | |
272 | clrwrite = tcbyt & (SIGC_WRITE ^ 0xff); | |
273 | setwrite = tcbyt | SIGC_WRITE; | |
274 | ||
275 | snd_mtpav_mputreg(chip, DREG, byte); | |
276 | snd_mtpav_mputreg(chip, CREG, clrwrite); // clear write bit | |
277 | ||
278 | snd_mtpav_mputreg(chip, CREG, setwrite); // set write bit | |
279 | ||
280 | } | |
281 | ||
282 | ||
283 | /* | |
284 | */ | |
285 | ||
286 | /* call this with spin lock held */ | |
077d0ac5 TI |
287 | static void snd_mtpav_output_port_write(struct mtpav *mtp_card, |
288 | struct mtpav_port *portp, | |
4a4d2cfd | 289 | struct snd_rawmidi_substream *substream) |
1da177e4 LT |
290 | { |
291 | u8 outbyte; | |
292 | ||
293 | // Get the outbyte first, so we can emulate running status if | |
294 | // necessary | |
295 | if (snd_rawmidi_transmit(substream, &outbyte, 1) != 1) | |
296 | return; | |
297 | ||
298 | // send port change command if necessary | |
299 | ||
077d0ac5 TI |
300 | if (portp->hwport != mtp_card->outmidihwport) { |
301 | mtp_card->outmidihwport = portp->hwport; | |
1da177e4 LT |
302 | |
303 | snd_mtpav_send_byte(mtp_card, 0xf5); | |
077d0ac5 | 304 | snd_mtpav_send_byte(mtp_card, portp->hwport); |
45203832 TI |
305 | /* |
306 | snd_printk(KERN_DEBUG "new outport: 0x%x\n", | |
307 | (unsigned int) portp->hwport); | |
308 | */ | |
077d0ac5 TI |
309 | if (!(outbyte & 0x80) && portp->running_status) |
310 | snd_mtpav_send_byte(mtp_card, portp->running_status); | |
1da177e4 LT |
311 | } |
312 | ||
313 | // send data | |
314 | ||
315 | do { | |
316 | if (outbyte & 0x80) | |
077d0ac5 | 317 | portp->running_status = outbyte; |
1da177e4 LT |
318 | |
319 | snd_mtpav_send_byte(mtp_card, outbyte); | |
320 | } while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1); | |
321 | } | |
322 | ||
4a4d2cfd | 323 | static void snd_mtpav_output_write(struct snd_rawmidi_substream *substream) |
1da177e4 | 324 | { |
077d0ac5 TI |
325 | struct mtpav *mtp_card = substream->rmidi->private_data; |
326 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 LT |
327 | unsigned long flags; |
328 | ||
329 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
077d0ac5 | 330 | snd_mtpav_output_port_write(mtp_card, portp, substream); |
1da177e4 LT |
331 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); |
332 | } | |
333 | ||
334 | ||
335 | /* | |
336 | * mtpav control | |
337 | */ | |
338 | ||
077d0ac5 | 339 | static void snd_mtpav_portscan(struct mtpav *chip) // put mtp into smart routing mode |
1da177e4 LT |
340 | { |
341 | u8 p; | |
342 | ||
343 | for (p = 0; p < 8; p++) { | |
344 | snd_mtpav_send_byte(chip, 0xf5); | |
345 | snd_mtpav_send_byte(chip, p); | |
346 | snd_mtpav_send_byte(chip, 0xfe); | |
347 | } | |
348 | } | |
349 | ||
350 | /* | |
351 | */ | |
352 | ||
4a4d2cfd | 353 | static int snd_mtpav_input_open(struct snd_rawmidi_substream *substream) |
1da177e4 | 354 | { |
077d0ac5 TI |
355 | struct mtpav *mtp_card = substream->rmidi->private_data; |
356 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 | 357 | unsigned long flags; |
1da177e4 | 358 | |
1da177e4 LT |
359 | spin_lock_irqsave(&mtp_card->spinlock, flags); |
360 | portp->mode |= MTPAV_MODE_INPUT_OPENED; | |
361 | portp->input = substream; | |
362 | if (mtp_card->share_irq++ == 0) | |
363 | snd_mtpav_mputreg(mtp_card, CREG, (SIGC_INTEN | SIGC_WRITE)); // enable pport interrupts | |
364 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
365 | return 0; | |
366 | } | |
367 | ||
368 | /* | |
369 | */ | |
370 | ||
4a4d2cfd | 371 | static int snd_mtpav_input_close(struct snd_rawmidi_substream *substream) |
1da177e4 | 372 | { |
077d0ac5 TI |
373 | struct mtpav *mtp_card = substream->rmidi->private_data; |
374 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 | 375 | unsigned long flags; |
1da177e4 LT |
376 | |
377 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
077d0ac5 | 378 | portp->mode &= ~MTPAV_MODE_INPUT_OPENED; |
1da177e4 LT |
379 | portp->input = NULL; |
380 | if (--mtp_card->share_irq == 0) | |
381 | snd_mtpav_mputreg(mtp_card, CREG, 0); // disable pport interrupts | |
1da177e4 LT |
382 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); |
383 | return 0; | |
384 | } | |
385 | ||
386 | /* | |
387 | */ | |
388 | ||
4a4d2cfd | 389 | static void snd_mtpav_input_trigger(struct snd_rawmidi_substream *substream, int up) |
1da177e4 | 390 | { |
077d0ac5 TI |
391 | struct mtpav *mtp_card = substream->rmidi->private_data; |
392 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 | 393 | unsigned long flags; |
1da177e4 LT |
394 | |
395 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
396 | if (up) | |
397 | portp->mode |= MTPAV_MODE_INPUT_TRIGGERED; | |
398 | else | |
399 | portp->mode &= ~MTPAV_MODE_INPUT_TRIGGERED; | |
400 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
401 | ||
402 | } | |
403 | ||
404 | ||
405 | /* | |
406 | * timer interrupt for outputs | |
407 | */ | |
408 | ||
409 | static void snd_mtpav_output_timer(unsigned long data) | |
410 | { | |
411 | unsigned long flags; | |
077d0ac5 | 412 | struct mtpav *chip = (struct mtpav *)data; |
1da177e4 LT |
413 | int p; |
414 | ||
415 | spin_lock_irqsave(&chip->spinlock, flags); | |
416 | /* reprogram timer */ | |
417 | chip->timer.expires = 1 + jiffies; | |
418 | add_timer(&chip->timer); | |
419 | /* process each port */ | |
420 | for (p = 0; p <= chip->num_ports * 2 + MTPAV_PIDX_BROADCAST; p++) { | |
077d0ac5 | 421 | struct mtpav_port *portp = &chip->ports[p]; |
1da177e4 | 422 | if ((portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && portp->output) |
077d0ac5 | 423 | snd_mtpav_output_port_write(chip, portp, portp->output); |
1da177e4 LT |
424 | } |
425 | spin_unlock_irqrestore(&chip->spinlock, flags); | |
426 | } | |
427 | ||
428 | /* spinlock held! */ | |
077d0ac5 | 429 | static void snd_mtpav_add_output_timer(struct mtpav *chip) |
1da177e4 | 430 | { |
1da177e4 LT |
431 | chip->timer.expires = 1 + jiffies; |
432 | add_timer(&chip->timer); | |
433 | } | |
434 | ||
435 | /* spinlock held! */ | |
077d0ac5 | 436 | static void snd_mtpav_remove_output_timer(struct mtpav *chip) |
1da177e4 LT |
437 | { |
438 | del_timer(&chip->timer); | |
439 | } | |
440 | ||
441 | /* | |
442 | */ | |
443 | ||
4a4d2cfd | 444 | static int snd_mtpav_output_open(struct snd_rawmidi_substream *substream) |
1da177e4 | 445 | { |
077d0ac5 TI |
446 | struct mtpav *mtp_card = substream->rmidi->private_data; |
447 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 | 448 | unsigned long flags; |
1da177e4 LT |
449 | |
450 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
451 | portp->mode |= MTPAV_MODE_OUTPUT_OPENED; | |
452 | portp->output = substream; | |
453 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
454 | return 0; | |
455 | }; | |
456 | ||
457 | /* | |
458 | */ | |
459 | ||
4a4d2cfd | 460 | static int snd_mtpav_output_close(struct snd_rawmidi_substream *substream) |
1da177e4 | 461 | { |
077d0ac5 TI |
462 | struct mtpav *mtp_card = substream->rmidi->private_data; |
463 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 | 464 | unsigned long flags; |
1da177e4 LT |
465 | |
466 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
077d0ac5 | 467 | portp->mode &= ~MTPAV_MODE_OUTPUT_OPENED; |
1da177e4 LT |
468 | portp->output = NULL; |
469 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
470 | return 0; | |
471 | }; | |
472 | ||
473 | /* | |
474 | */ | |
475 | ||
4a4d2cfd | 476 | static void snd_mtpav_output_trigger(struct snd_rawmidi_substream *substream, int up) |
1da177e4 | 477 | { |
077d0ac5 TI |
478 | struct mtpav *mtp_card = substream->rmidi->private_data; |
479 | struct mtpav_port *portp = &mtp_card->ports[substream->number]; | |
1da177e4 | 480 | unsigned long flags; |
1da177e4 LT |
481 | |
482 | spin_lock_irqsave(&mtp_card->spinlock, flags); | |
483 | if (up) { | |
077d0ac5 | 484 | if (! (portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED)) { |
1da177e4 LT |
485 | if (mtp_card->istimer++ == 0) |
486 | snd_mtpav_add_output_timer(mtp_card); | |
487 | portp->mode |= MTPAV_MODE_OUTPUT_TRIGGERED; | |
488 | } | |
489 | } else { | |
490 | portp->mode &= ~MTPAV_MODE_OUTPUT_TRIGGERED; | |
491 | if (--mtp_card->istimer == 0) | |
492 | snd_mtpav_remove_output_timer(mtp_card); | |
493 | } | |
494 | spin_unlock_irqrestore(&mtp_card->spinlock, flags); | |
495 | ||
496 | if (up) | |
497 | snd_mtpav_output_write(substream); | |
498 | } | |
499 | ||
500 | /* | |
501 | * midi interrupt for inputs | |
502 | */ | |
503 | ||
077d0ac5 | 504 | static void snd_mtpav_inmidi_process(struct mtpav *mcrd, u8 inbyte) |
1da177e4 | 505 | { |
077d0ac5 | 506 | struct mtpav_port *portp; |
1da177e4 LT |
507 | |
508 | if ((int)mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST) | |
509 | return; | |
510 | ||
511 | portp = &mcrd->ports[mcrd->inmidiport]; | |
077d0ac5 | 512 | if (portp->mode & MTPAV_MODE_INPUT_TRIGGERED) |
1da177e4 | 513 | snd_rawmidi_receive(portp->input, &inbyte, 1); |
1da177e4 LT |
514 | } |
515 | ||
077d0ac5 | 516 | static void snd_mtpav_inmidi_h(struct mtpav *mcrd, u8 inbyte) |
1da177e4 | 517 | { |
1da177e4 LT |
518 | if (inbyte >= 0xf8) { |
519 | /* real-time midi code */ | |
520 | snd_mtpav_inmidi_process(mcrd, inbyte); | |
521 | return; | |
522 | } | |
523 | ||
524 | if (mcrd->inmidistate == 0) { // awaiting command | |
525 | if (inbyte == 0xf5) // MTP port # | |
526 | mcrd->inmidistate = 1; | |
527 | else | |
528 | snd_mtpav_inmidi_process(mcrd, inbyte); | |
529 | } else if (mcrd->inmidistate) { | |
530 | mcrd->inmidiport = translate_hwport_to_subdevice(mcrd, inbyte); | |
531 | mcrd->inmidistate = 0; | |
532 | } | |
533 | } | |
534 | ||
077d0ac5 | 535 | static void snd_mtpav_read_bytes(struct mtpav *mcrd) |
1da177e4 LT |
536 | { |
537 | u8 clrread, setread; | |
538 | u8 mtp_read_byte; | |
539 | u8 sr, cbyt; | |
540 | int i; | |
541 | ||
542 | u8 sbyt = snd_mtpav_getreg(mcrd, SREG); | |
543 | ||
45203832 | 544 | /* printk(KERN_DEBUG "snd_mtpav_read_bytes() sbyt: 0x%x\n", sbyt); */ |
1da177e4 LT |
545 | |
546 | if (!(sbyt & SIGS_BYTE)) | |
547 | return; | |
548 | ||
549 | cbyt = snd_mtpav_getreg(mcrd, CREG); | |
550 | clrread = cbyt & (SIGC_READ ^ 0xff); | |
551 | setread = cbyt | SIGC_READ; | |
552 | ||
553 | do { | |
554 | ||
555 | mtp_read_byte = 0; | |
556 | for (i = 0; i < 4; i++) { | |
557 | snd_mtpav_mputreg(mcrd, CREG, setread); | |
558 | sr = snd_mtpav_getreg(mcrd, SREG); | |
559 | snd_mtpav_mputreg(mcrd, CREG, clrread); | |
560 | ||
561 | sr &= SIGS_IN0 | SIGS_IN1; | |
562 | sr >>= 4; | |
563 | mtp_read_byte |= sr << (i * 2); | |
564 | } | |
565 | ||
566 | snd_mtpav_inmidi_h(mcrd, mtp_read_byte); | |
567 | ||
568 | sbyt = snd_mtpav_getreg(mcrd, SREG); | |
569 | ||
570 | } while (sbyt & SIGS_BYTE); | |
571 | } | |
572 | ||
7d12e780 | 573 | static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id) |
1da177e4 | 574 | { |
077d0ac5 | 575 | struct mtpav *mcard = dev_id; |
1da177e4 | 576 | |
1da177e4 LT |
577 | spin_lock(&mcard->spinlock); |
578 | snd_mtpav_read_bytes(mcard); | |
579 | spin_unlock(&mcard->spinlock); | |
580 | return IRQ_HANDLED; | |
581 | } | |
582 | ||
583 | /* | |
584 | * get ISA resources | |
585 | */ | |
788c6043 | 586 | static int __devinit snd_mtpav_get_ISA(struct mtpav * mcard) |
1da177e4 LT |
587 | { |
588 | if ((mcard->res_port = request_region(port, 3, "MotuMTPAV MIDI")) == NULL) { | |
45203832 | 589 | snd_printk(KERN_ERR "MTVAP port 0x%lx is busy\n", port); |
1da177e4 LT |
590 | return -EBUSY; |
591 | } | |
592 | mcard->port = port; | |
88e24c3a | 593 | if (request_irq(irq, snd_mtpav_irqh, 0, "MOTU MTPAV", mcard)) { |
45203832 | 594 | snd_printk(KERN_ERR "MTVAP IRQ %d busy\n", irq); |
1da177e4 LT |
595 | return -EBUSY; |
596 | } | |
597 | mcard->irq = irq; | |
598 | return 0; | |
599 | } | |
600 | ||
601 | ||
602 | /* | |
603 | */ | |
604 | ||
4a4d2cfd | 605 | static struct snd_rawmidi_ops snd_mtpav_output = { |
1da177e4 LT |
606 | .open = snd_mtpav_output_open, |
607 | .close = snd_mtpav_output_close, | |
608 | .trigger = snd_mtpav_output_trigger, | |
609 | }; | |
610 | ||
4a4d2cfd | 611 | static struct snd_rawmidi_ops snd_mtpav_input = { |
1da177e4 LT |
612 | .open = snd_mtpav_input_open, |
613 | .close = snd_mtpav_input_close, | |
614 | .trigger = snd_mtpav_input_trigger, | |
615 | }; | |
616 | ||
617 | ||
618 | /* | |
619 | * get RAWMIDI resources | |
620 | */ | |
621 | ||
788c6043 | 622 | static void __devinit snd_mtpav_set_name(struct mtpav *chip, |
077d0ac5 | 623 | struct snd_rawmidi_substream *substream) |
1da177e4 LT |
624 | { |
625 | if (substream->number >= 0 && substream->number < chip->num_ports) | |
626 | sprintf(substream->name, "MTP direct %d", (substream->number % chip->num_ports) + 1); | |
627 | else if (substream->number >= 8 && substream->number < chip->num_ports * 2) | |
628 | sprintf(substream->name, "MTP remote %d", (substream->number % chip->num_ports) + 1); | |
629 | else if (substream->number == chip->num_ports * 2) | |
630 | strcpy(substream->name, "MTP computer"); | |
631 | else if (substream->number == chip->num_ports * 2 + 1) | |
632 | strcpy(substream->name, "MTP ADAT"); | |
633 | else | |
634 | strcpy(substream->name, "MTP broadcast"); | |
635 | } | |
636 | ||
788c6043 | 637 | static int __devinit snd_mtpav_get_RAWMIDI(struct mtpav *mcard) |
1da177e4 | 638 | { |
077d0ac5 | 639 | int rval; |
4a4d2cfd TI |
640 | struct snd_rawmidi *rawmidi; |
641 | struct snd_rawmidi_substream *substream; | |
1da177e4 LT |
642 | struct list_head *list; |
643 | ||
1da177e4 | 644 | if (hwports < 1) |
077d0ac5 | 645 | hwports = 1; |
1da177e4 | 646 | else if (hwports > 8) |
077d0ac5 TI |
647 | hwports = 8; |
648 | mcard->num_ports = hwports; | |
1da177e4 LT |
649 | |
650 | if ((rval = snd_rawmidi_new(mcard->card, "MotuMIDI", 0, | |
651 | mcard->num_ports * 2 + MTPAV_PIDX_BROADCAST + 1, | |
652 | mcard->num_ports * 2 + MTPAV_PIDX_BROADCAST + 1, | |
653 | &mcard->rmidi)) < 0) | |
654 | return rval; | |
655 | rawmidi = mcard->rmidi; | |
077d0ac5 | 656 | rawmidi->private_data = mcard; |
1da177e4 LT |
657 | |
658 | list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { | |
4a4d2cfd | 659 | substream = list_entry(list, struct snd_rawmidi_substream, list); |
1da177e4 LT |
660 | snd_mtpav_set_name(mcard, substream); |
661 | substream->ops = &snd_mtpav_input; | |
662 | } | |
663 | list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { | |
4a4d2cfd | 664 | substream = list_entry(list, struct snd_rawmidi_substream, list); |
1da177e4 LT |
665 | snd_mtpav_set_name(mcard, substream); |
666 | substream->ops = &snd_mtpav_output; | |
667 | mcard->ports[substream->number].hwport = translate_subdevice_to_hwport(mcard, substream->number); | |
668 | } | |
669 | rawmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | | |
670 | SNDRV_RAWMIDI_INFO_DUPLEX; | |
671 | sprintf(rawmidi->name, "MTP AV MIDI"); | |
1da177e4 LT |
672 | return 0; |
673 | } | |
674 | ||
675 | /* | |
676 | */ | |
677 | ||
077d0ac5 | 678 | static void snd_mtpav_free(struct snd_card *card) |
1da177e4 | 679 | { |
077d0ac5 | 680 | struct mtpav *crd = card->private_data; |
1da177e4 LT |
681 | unsigned long flags; |
682 | ||
683 | spin_lock_irqsave(&crd->spinlock, flags); | |
684 | if (crd->istimer > 0) | |
685 | snd_mtpav_remove_output_timer(crd); | |
686 | spin_unlock_irqrestore(&crd->spinlock, flags); | |
687 | if (crd->irq >= 0) | |
688 | free_irq(crd->irq, (void *)crd); | |
b1d5776d | 689 | release_and_free_resource(crd->res_port); |
1da177e4 LT |
690 | } |
691 | ||
692 | /* | |
693 | */ | |
788c6043 | 694 | static int __devinit snd_mtpav_probe(struct platform_device *dev) |
1da177e4 | 695 | { |
077d0ac5 TI |
696 | struct snd_card *card; |
697 | int err; | |
698 | struct mtpav *mtp_card; | |
1da177e4 | 699 | |
bd7dd77c TI |
700 | err = snd_card_create(index, id, THIS_MODULE, sizeof(*mtp_card), &card); |
701 | if (err < 0) | |
702 | return err; | |
1da177e4 | 703 | |
077d0ac5 TI |
704 | mtp_card = card->private_data; |
705 | spin_lock_init(&mtp_card->spinlock); | |
706 | init_timer(&mtp_card->timer); | |
707 | mtp_card->card = card; | |
708 | mtp_card->irq = -1; | |
709 | mtp_card->share_irq = 0; | |
077d0ac5 TI |
710 | mtp_card->inmidistate = 0; |
711 | mtp_card->outmidihwport = 0xffffffff; | |
712 | init_timer(&mtp_card->timer); | |
713 | mtp_card->timer.function = snd_mtpav_output_timer; | |
714 | mtp_card->timer.data = (unsigned long) mtp_card; | |
715 | ||
716 | card->private_free = snd_mtpav_free; | |
1da177e4 | 717 | |
32fe6142 TI |
718 | err = snd_mtpav_get_RAWMIDI(mtp_card); |
719 | if (err < 0) | |
720 | goto __error; | |
721 | ||
32cf9a16 TI |
722 | mtp_card->inmidiport = mtp_card->num_ports + MTPAV_PIDX_BROADCAST; |
723 | ||
1da177e4 | 724 | err = snd_mtpav_get_ISA(mtp_card); |
1da177e4 LT |
725 | if (err < 0) |
726 | goto __error; | |
727 | ||
077d0ac5 TI |
728 | strcpy(card->driver, "MTPAV"); |
729 | strcpy(card->shortname, "MTPAV on parallel port"); | |
730 | snprintf(card->longname, sizeof(card->longname), | |
731 | "MTPAV on parallel port at 0x%lx", port); | |
1da177e4 | 732 | |
077d0ac5 | 733 | snd_mtpav_portscan(mtp_card); |
1da177e4 | 734 | |
077d0ac5 TI |
735 | snd_card_set_dev(card, &dev->dev); |
736 | err = snd_card_register(mtp_card->card); | |
1da177e4 LT |
737 | if (err < 0) |
738 | goto __error; | |
739 | ||
077d0ac5 | 740 | platform_set_drvdata(dev, card); |
1da177e4 | 741 | printk(KERN_INFO "Motu MidiTimePiece on parallel port irq: %d ioport: 0x%lx\n", irq, port); |
1da177e4 LT |
742 | return 0; |
743 | ||
077d0ac5 TI |
744 | __error: |
745 | snd_card_free(card); | |
1da177e4 LT |
746 | return err; |
747 | } | |
748 | ||
788c6043 | 749 | static int __devexit snd_mtpav_remove(struct platform_device *devptr) |
077d0ac5 TI |
750 | { |
751 | snd_card_free(platform_get_drvdata(devptr)); | |
752 | platform_set_drvdata(devptr, NULL); | |
753 | return 0; | |
754 | } | |
1da177e4 | 755 | |
077d0ac5 TI |
756 | #define SND_MTPAV_DRIVER "snd_mtpav" |
757 | ||
758 | static struct platform_driver snd_mtpav_driver = { | |
759 | .probe = snd_mtpav_probe, | |
788c6043 | 760 | .remove = __devexit_p(snd_mtpav_remove), |
077d0ac5 | 761 | .driver = { |
8bf01d8a TI |
762 | .name = SND_MTPAV_DRIVER, |
763 | .owner = THIS_MODULE, | |
077d0ac5 TI |
764 | }, |
765 | }; | |
766 | ||
767 | static int __init alsa_card_mtpav_init(void) | |
1da177e4 | 768 | { |
077d0ac5 | 769 | int err; |
077d0ac5 TI |
770 | |
771 | if ((err = platform_driver_register(&snd_mtpav_driver)) < 0) | |
772 | return err; | |
773 | ||
774 | device = platform_device_register_simple(SND_MTPAV_DRIVER, -1, NULL, 0); | |
7152447d RH |
775 | if (!IS_ERR(device)) { |
776 | if (platform_get_drvdata(device)) | |
777 | return 0; | |
778 | platform_device_unregister(device); | |
779 | err = -ENODEV; | |
780 | } else | |
781 | err = PTR_ERR(device); | |
782 | platform_driver_unregister(&snd_mtpav_driver); | |
783 | return err; | |
1da177e4 LT |
784 | } |
785 | ||
077d0ac5 TI |
786 | static void __exit alsa_card_mtpav_exit(void) |
787 | { | |
f7a9275d | 788 | platform_device_unregister(device); |
077d0ac5 TI |
789 | platform_driver_unregister(&snd_mtpav_driver); |
790 | } | |
1da177e4 LT |
791 | |
792 | module_init(alsa_card_mtpav_init) | |
793 | module_exit(alsa_card_mtpav_exit) |