2 * ALSA Driver for Ego Systems Inc. (ESI) Miditerminal 4140
3 * Copyright (c) 2006 by Matthias König <mk@phasorlab.de>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 #include <sound/driver.h>
22 #include <linux/init.h>
23 #include <linux/platform_device.h>
24 #include <linux/parport.h>
25 #include <linux/spinlock.h>
26 #include <linux/delay.h>
27 #include <sound/core.h>
28 #include <sound/initval.h>
29 #include <sound/rawmidi.h>
30 #include <sound/control.h>
32 #define CARD_NAME "Miditerminal 4140"
33 #define DRIVER_NAME "MTS64"
34 #define PLATFORM_DRIVER "snd_mts64"
36 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
37 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
38 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
40 static struct platform_device
*platform_devices
[SNDRV_CARDS
];
41 static int device_count
;
43 module_param_array(index
, int, NULL
, S_IRUGO
);
44 MODULE_PARM_DESC(index
, "Index value for " CARD_NAME
" soundcard.");
45 module_param_array(id
, charp
, NULL
, S_IRUGO
);
46 MODULE_PARM_DESC(id
, "ID string for " CARD_NAME
" soundcard.");
47 module_param_array(enable
, bool, NULL
, S_IRUGO
);
48 MODULE_PARM_DESC(enable
, "Enable " CARD_NAME
" soundcard.");
50 MODULE_AUTHOR("Matthias Koenig <mk@phasorlab.de>");
51 MODULE_DESCRIPTION("ESI Miditerminal 4140");
52 MODULE_LICENSE("GPL");
53 MODULE_SUPPORTED_DEVICE("{{ESI,Miditerminal 4140}}");
55 /*********************************************************************
57 *********************************************************************/
58 #define MTS64_NUM_INPUT_PORTS 5
59 #define MTS64_NUM_OUTPUT_PORTS 4
60 #define MTS64_SMPTE_SUBSTREAM 4
64 struct snd_card
*card
;
65 struct snd_rawmidi
*rmidi
;
66 struct pardevice
*pardev
;
70 int current_midi_output_port
;
71 int current_midi_input_port
;
72 u8 mode
[MTS64_NUM_INPUT_PORTS
];
73 struct snd_rawmidi_substream
*midi_input_substream
[MTS64_NUM_INPUT_PORTS
];
75 u8 time
[4]; /* [0]=hh, [1]=mm, [2]=ss, [3]=ff */
79 static int snd_mts64_free(struct mts64
*mts
)
85 static int __devinit
snd_mts64_create(struct snd_card
*card
,
86 struct pardevice
*pardev
,
93 mts
= kzalloc(sizeof(struct mts64
), GFP_KERNEL
);
97 /* Init chip specific data */
98 spin_lock_init(&mts
->lock
);
100 mts
->pardev
= pardev
;
101 mts
->current_midi_output_port
= -1;
102 mts
->current_midi_input_port
= -1;
109 /*********************************************************************
110 * HW register related constants
111 *********************************************************************/
114 #define MTS64_STAT_BSY 0x80
115 #define MTS64_STAT_BIT_SET 0x20 /* readout process, bit is set */
116 #define MTS64_STAT_PORT 0x10 /* read byte is a port number */
119 #define MTS64_CTL_READOUT 0x08 /* enable readout */
120 #define MTS64_CTL_WRITE_CMD 0x06
121 #define MTS64_CTL_WRITE_DATA 0x02
122 #define MTS64_CTL_STROBE 0x01
125 #define MTS64_CMD_RESET 0xfe
126 #define MTS64_CMD_PROBE 0x8f /* Used in probing procedure */
127 #define MTS64_CMD_SMPTE_SET_TIME 0xe8
128 #define MTS64_CMD_SMPTE_SET_FPS 0xee
129 #define MTS64_CMD_SMPTE_STOP 0xef
130 #define MTS64_CMD_SMPTE_FPS_24 0xe3
131 #define MTS64_CMD_SMPTE_FPS_25 0xe2
132 #define MTS64_CMD_SMPTE_FPS_2997 0xe4
133 #define MTS64_CMD_SMPTE_FPS_30D 0xe1
134 #define MTS64_CMD_SMPTE_FPS_30 0xe0
135 #define MTS64_CMD_COM_OPEN 0xf8 /* setting the communication mode */
136 #define MTS64_CMD_COM_CLOSE1 0xff /* clearing communication mode */
137 #define MTS64_CMD_COM_CLOSE2 0xf5
139 /*********************************************************************
140 * Hardware specific functions
141 *********************************************************************/
142 static void mts64_enable_readout(struct parport
*p
);
143 static void mts64_disable_readout(struct parport
*p
);
144 static int mts64_device_ready(struct parport
*p
);
145 static int mts64_device_init(struct parport
*p
);
146 static int mts64_device_open(struct mts64
*mts
);
147 static int mts64_device_close(struct mts64
*mts
);
148 static u8
mts64_map_midi_input(u8 c
);
149 static int mts64_probe(struct parport
*p
);
150 static u16
mts64_read(struct parport
*p
);
151 static u8
mts64_read_char(struct parport
*p
);
152 static void mts64_smpte_start(struct parport
*p
,
153 u8 hours
, u8 minutes
,
154 u8 seconds
, u8 frames
,
156 static void mts64_smpte_stop(struct parport
*p
);
157 static void mts64_write_command(struct parport
*p
, u8 c
);
158 static void mts64_write_data(struct parport
*p
, u8 c
);
159 static void mts64_write_midi(struct mts64
*mts
, u8 c
, int midiport
);
162 /* Enables the readout procedure
164 * Before we can read a midi byte from the device, we have to set
165 * bit 3 of control port.
167 static void mts64_enable_readout(struct parport
*p
)
171 c
= parport_read_control(p
);
172 c
|= MTS64_CTL_READOUT
;
173 parport_write_control(p
, c
);
178 * Readout is disabled by clearing bit 3 of control
180 static void mts64_disable_readout(struct parport
*p
)
184 c
= parport_read_control(p
);
185 c
&= ~MTS64_CTL_READOUT
;
186 parport_write_control(p
, c
);
189 /* waits for device ready
191 * Checks if BUSY (Bit 7 of status) is clear
195 static int mts64_device_ready(struct parport
*p
)
200 for (i
= 0; i
< 0xffff; ++i
) {
201 c
= parport_read_status(p
);
210 /* Init device (LED blinking startup magic)
216 static int __devinit
mts64_device_init(struct parport
*p
)
220 mts64_write_command(p
, MTS64_CMD_RESET
);
222 for (i
= 0; i
< 64; ++i
) {
225 if (mts64_probe(p
) == 0) {
227 mts64_disable_readout(p
);
231 mts64_disable_readout(p
);
237 * Opens the device (set communication mode)
239 static int mts64_device_open(struct mts64
*mts
)
242 struct parport
*p
= mts
->pardev
->port
;
244 for (i
= 0; i
< 5; ++i
)
245 mts64_write_command(p
, MTS64_CMD_COM_OPEN
);
251 * Close device (clear communication mode)
253 static int mts64_device_close(struct mts64
*mts
)
256 struct parport
*p
= mts
->pardev
->port
;
258 for (i
= 0; i
< 5; ++i
) {
259 mts64_write_command(p
, MTS64_CMD_COM_CLOSE1
);
260 mts64_write_command(p
, MTS64_CMD_COM_CLOSE2
);
266 /* map hardware port to substream number
268 * When reading a byte from the device, the device tells us
269 * on what port the byte is. This HW port has to be mapped to
270 * the midiport (substream number).
271 * substream 0-3 are Midiports 1-4
272 * substream 4 is SMPTE Timecode
273 * The mapping is done by the table:
274 * HW | 0 | 1 | 2 | 3 | 4
275 * SW | 0 | 1 | 4 | 2 | 3
277 static u8
mts64_map_midi_input(u8 c
)
279 static u8 map
[] = { 0, 1, 4, 2, 3 };
285 /* Probe parport for device
287 * Do we have a Miditerminal 4140 on parport?
292 static int __devinit
mts64_probe(struct parport
*p
)
297 mts64_write_command(p
, MTS64_CMD_PROBE
);
304 if (c
!= MTS64_CMD_PROBE
)
311 /* Read byte incl. status from device
314 * data in lower 8 bits and status in upper 8 bits
316 static u16
mts64_read(struct parport
*p
)
320 mts64_device_ready(p
);
321 mts64_enable_readout(p
);
322 status
= parport_read_status(p
);
323 data
= mts64_read_char(p
);
324 mts64_disable_readout(p
);
326 return (status
<< 8) | data
;
329 /* Read a byte from device
331 * Note, that readout mode has to be enabled.
332 * readout procedure is as follows:
333 * - Write number of the Bit to read to DATA
335 * - Bit 5 of STATUS indicates if Bit is set
338 * Byte read from device
340 static u8
mts64_read_char(struct parport
*p
)
346 for (i
= 0; i
< 8; ++i
) {
347 parport_write_data(p
, i
);
349 status
= parport_read_status(p
);
350 if (status
& MTS64_STAT_BIT_SET
)
357 /* Starts SMPTE Timecode generation
359 * The device creates SMPTE Timecode by hardware.
363 * 3 30 fps (Drop-frame)
366 static void mts64_smpte_start(struct parport
*p
,
367 u8 hours
, u8 minutes
,
368 u8 seconds
, u8 frames
,
371 static u8 fps
[5] = { MTS64_CMD_SMPTE_FPS_24
,
372 MTS64_CMD_SMPTE_FPS_25
,
373 MTS64_CMD_SMPTE_FPS_2997
,
374 MTS64_CMD_SMPTE_FPS_30D
,
375 MTS64_CMD_SMPTE_FPS_30
};
377 mts64_write_command(p
, MTS64_CMD_SMPTE_SET_TIME
);
378 mts64_write_command(p
, frames
);
379 mts64_write_command(p
, seconds
);
380 mts64_write_command(p
, minutes
);
381 mts64_write_command(p
, hours
);
383 mts64_write_command(p
, MTS64_CMD_SMPTE_SET_FPS
);
384 mts64_write_command(p
, fps
[idx
]);
387 /* Stops SMPTE Timecode generation
389 static void mts64_smpte_stop(struct parport
*p
)
391 mts64_write_command(p
, MTS64_CMD_SMPTE_STOP
);
394 /* Write a command byte to device
396 static void mts64_write_command(struct parport
*p
, u8 c
)
398 mts64_device_ready(p
);
400 parport_write_data(p
, c
);
402 parport_write_control(p
, MTS64_CTL_WRITE_CMD
);
403 parport_write_control(p
, MTS64_CTL_WRITE_CMD
| MTS64_CTL_STROBE
);
404 parport_write_control(p
, MTS64_CTL_WRITE_CMD
);
407 /* Write a data byte to device
409 static void mts64_write_data(struct parport
*p
, u8 c
)
411 mts64_device_ready(p
);
413 parport_write_data(p
, c
);
415 parport_write_control(p
, MTS64_CTL_WRITE_DATA
);
416 parport_write_control(p
, MTS64_CTL_WRITE_DATA
| MTS64_CTL_STROBE
);
417 parport_write_control(p
, MTS64_CTL_WRITE_DATA
);
420 /* Write a MIDI byte to midiport
422 * midiport ranges from 0-3 and maps to Ports 1-4
423 * assumptions: communication mode is on
425 static void mts64_write_midi(struct mts64
*mts
, u8 c
,
428 struct parport
*p
= mts
->pardev
->port
;
430 /* check current midiport */
431 if (mts
->current_midi_output_port
!= midiport
)
432 mts64_write_command(p
, midiport
);
434 /* write midi byte */
435 mts64_write_data(p
, c
);
438 /*********************************************************************
440 *********************************************************************/
443 #define snd_mts64_ctl_smpte_switch_info snd_ctl_boolean_mono_info
445 static int snd_mts64_ctl_smpte_switch_get(struct snd_kcontrol
* kctl
,
446 struct snd_ctl_elem_value
*uctl
)
448 struct mts64
*mts
= snd_kcontrol_chip(kctl
);
450 spin_lock_irq(&mts
->lock
);
451 uctl
->value
.integer
.value
[0] = mts
->smpte_switch
;
452 spin_unlock_irq(&mts
->lock
);
457 /* smpte_switch is not accessed from IRQ handler, so we just need
458 to protect the HW access */
459 static int snd_mts64_ctl_smpte_switch_put(struct snd_kcontrol
* kctl
,
460 struct snd_ctl_elem_value
*uctl
)
462 struct mts64
*mts
= snd_kcontrol_chip(kctl
);
465 spin_lock_irq(&mts
->lock
);
466 if (mts
->smpte_switch
== uctl
->value
.integer
.value
[0])
470 mts
->smpte_switch
= uctl
->value
.integer
.value
[0];
471 if (mts
->smpte_switch
) {
472 mts64_smpte_start(mts
->pardev
->port
,
473 mts
->time
[0], mts
->time
[1],
474 mts
->time
[2], mts
->time
[3],
477 mts64_smpte_stop(mts
->pardev
->port
);
480 spin_unlock_irq(&mts
->lock
);
484 static struct snd_kcontrol_new mts64_ctl_smpte_switch __devinitdata
= {
485 .iface
= SNDRV_CTL_ELEM_IFACE_RAWMIDI
,
486 .name
= "SMPTE Playback Switch",
488 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
490 .info
= snd_mts64_ctl_smpte_switch_info
,
491 .get
= snd_mts64_ctl_smpte_switch_get
,
492 .put
= snd_mts64_ctl_smpte_switch_put
496 static int snd_mts64_ctl_smpte_time_h_info(struct snd_kcontrol
*kctl
,
497 struct snd_ctl_elem_info
*uinfo
)
499 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
501 uinfo
->value
.integer
.min
= 0;
502 uinfo
->value
.integer
.max
= 23;
506 static int snd_mts64_ctl_smpte_time_f_info(struct snd_kcontrol
*kctl
,
507 struct snd_ctl_elem_info
*uinfo
)
509 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
511 uinfo
->value
.integer
.min
= 0;
512 uinfo
->value
.integer
.max
= 99;
516 static int snd_mts64_ctl_smpte_time_info(struct snd_kcontrol
*kctl
,
517 struct snd_ctl_elem_info
*uinfo
)
519 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
521 uinfo
->value
.integer
.min
= 0;
522 uinfo
->value
.integer
.max
= 59;
526 static int snd_mts64_ctl_smpte_time_get(struct snd_kcontrol
*kctl
,
527 struct snd_ctl_elem_value
*uctl
)
529 struct mts64
*mts
= snd_kcontrol_chip(kctl
);
530 int idx
= kctl
->private_value
;
532 spin_lock_irq(&mts
->lock
);
533 uctl
->value
.integer
.value
[0] = mts
->time
[idx
];
534 spin_unlock_irq(&mts
->lock
);
539 static int snd_mts64_ctl_smpte_time_put(struct snd_kcontrol
*kctl
,
540 struct snd_ctl_elem_value
*uctl
)
542 struct mts64
*mts
= snd_kcontrol_chip(kctl
);
543 int idx
= kctl
->private_value
;
546 spin_lock_irq(&mts
->lock
);
547 if (mts
->time
[idx
] != uctl
->value
.integer
.value
[0]) {
549 mts
->time
[idx
] = uctl
->value
.integer
.value
[0];
551 spin_unlock_irq(&mts
->lock
);
556 static struct snd_kcontrol_new mts64_ctl_smpte_time_hours __devinitdata
= {
557 .iface
= SNDRV_CTL_ELEM_IFACE_RAWMIDI
,
558 .name
= "SMPTE Time Hours",
560 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
562 .info
= snd_mts64_ctl_smpte_time_h_info
,
563 .get
= snd_mts64_ctl_smpte_time_get
,
564 .put
= snd_mts64_ctl_smpte_time_put
567 static struct snd_kcontrol_new mts64_ctl_smpte_time_minutes __devinitdata
= {
568 .iface
= SNDRV_CTL_ELEM_IFACE_RAWMIDI
,
569 .name
= "SMPTE Time Minutes",
571 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
573 .info
= snd_mts64_ctl_smpte_time_info
,
574 .get
= snd_mts64_ctl_smpte_time_get
,
575 .put
= snd_mts64_ctl_smpte_time_put
578 static struct snd_kcontrol_new mts64_ctl_smpte_time_seconds __devinitdata
= {
579 .iface
= SNDRV_CTL_ELEM_IFACE_RAWMIDI
,
580 .name
= "SMPTE Time Seconds",
582 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
584 .info
= snd_mts64_ctl_smpte_time_info
,
585 .get
= snd_mts64_ctl_smpte_time_get
,
586 .put
= snd_mts64_ctl_smpte_time_put
589 static struct snd_kcontrol_new mts64_ctl_smpte_time_frames __devinitdata
= {
590 .iface
= SNDRV_CTL_ELEM_IFACE_RAWMIDI
,
591 .name
= "SMPTE Time Frames",
593 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
595 .info
= snd_mts64_ctl_smpte_time_f_info
,
596 .get
= snd_mts64_ctl_smpte_time_get
,
597 .put
= snd_mts64_ctl_smpte_time_put
601 static int snd_mts64_ctl_smpte_fps_info(struct snd_kcontrol
*kctl
,
602 struct snd_ctl_elem_info
*uinfo
)
604 static char *texts
[5] = { "24",
610 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
612 uinfo
->value
.enumerated
.items
= 5;
613 if (uinfo
->value
.enumerated
.item
> 4)
614 uinfo
->value
.enumerated
.item
= 4;
615 strcpy(uinfo
->value
.enumerated
.name
,
616 texts
[uinfo
->value
.enumerated
.item
]);
621 static int snd_mts64_ctl_smpte_fps_get(struct snd_kcontrol
*kctl
,
622 struct snd_ctl_elem_value
*uctl
)
624 struct mts64
*mts
= snd_kcontrol_chip(kctl
);
626 spin_lock_irq(&mts
->lock
);
627 uctl
->value
.enumerated
.item
[0] = mts
->fps
;
628 spin_unlock_irq(&mts
->lock
);
633 static int snd_mts64_ctl_smpte_fps_put(struct snd_kcontrol
*kctl
,
634 struct snd_ctl_elem_value
*uctl
)
636 struct mts64
*mts
= snd_kcontrol_chip(kctl
);
639 spin_lock_irq(&mts
->lock
);
640 if (mts
->fps
!= uctl
->value
.enumerated
.item
[0]) {
642 mts
->fps
= uctl
->value
.enumerated
.item
[0];
644 spin_unlock_irq(&mts
->lock
);
649 static struct snd_kcontrol_new mts64_ctl_smpte_fps __devinitdata
= {
650 .iface
= SNDRV_CTL_ELEM_IFACE_RAWMIDI
,
653 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
655 .info
= snd_mts64_ctl_smpte_fps_info
,
656 .get
= snd_mts64_ctl_smpte_fps_get
,
657 .put
= snd_mts64_ctl_smpte_fps_put
661 static int __devinit
snd_mts64_ctl_create(struct snd_card
*card
,
665 static struct snd_kcontrol_new
*control
[] = {
666 &mts64_ctl_smpte_switch
,
667 &mts64_ctl_smpte_time_hours
,
668 &mts64_ctl_smpte_time_minutes
,
669 &mts64_ctl_smpte_time_seconds
,
670 &mts64_ctl_smpte_time_frames
,
671 &mts64_ctl_smpte_fps
,
674 for (i
= 0; control
[i
]; ++i
) {
675 err
= snd_ctl_add(card
, snd_ctl_new1(control
[i
], mts
));
677 snd_printd("Cannot create control: %s\n",
686 /*********************************************************************
688 *********************************************************************/
689 #define MTS64_MODE_INPUT_TRIGGERED 0x01
691 static int snd_mts64_rawmidi_open(struct snd_rawmidi_substream
*substream
)
693 struct mts64
*mts
= substream
->rmidi
->private_data
;
695 if (mts
->open_count
== 0) {
696 /* We don't need a spinlock here, because this is just called
697 if the device has not been opened before.
698 So there aren't any IRQs from the device */
699 mts64_device_open(mts
);
708 static int snd_mts64_rawmidi_close(struct snd_rawmidi_substream
*substream
)
710 struct mts64
*mts
= substream
->rmidi
->private_data
;
714 if (mts
->open_count
== 0) {
715 /* We need the spinlock_irqsave here because we can still
716 have IRQs at this point */
717 spin_lock_irqsave(&mts
->lock
, flags
);
718 mts64_device_close(mts
);
719 spin_unlock_irqrestore(&mts
->lock
, flags
);
723 } else if (mts
->open_count
< 0)
729 static void snd_mts64_rawmidi_output_trigger(struct snd_rawmidi_substream
*substream
,
732 struct mts64
*mts
= substream
->rmidi
->private_data
;
736 spin_lock_irqsave(&mts
->lock
, flags
);
737 while (snd_rawmidi_transmit_peek(substream
, &data
, 1) == 1) {
738 mts64_write_midi(mts
, data
, substream
->number
+1);
739 snd_rawmidi_transmit_ack(substream
, 1);
741 spin_unlock_irqrestore(&mts
->lock
, flags
);
744 static void snd_mts64_rawmidi_input_trigger(struct snd_rawmidi_substream
*substream
,
747 struct mts64
*mts
= substream
->rmidi
->private_data
;
750 spin_lock_irqsave(&mts
->lock
, flags
);
752 mts
->mode
[substream
->number
] |= MTS64_MODE_INPUT_TRIGGERED
;
754 mts
->mode
[substream
->number
] &= ~MTS64_MODE_INPUT_TRIGGERED
;
756 spin_unlock_irqrestore(&mts
->lock
, flags
);
759 static struct snd_rawmidi_ops snd_mts64_rawmidi_output_ops
= {
760 .open
= snd_mts64_rawmidi_open
,
761 .close
= snd_mts64_rawmidi_close
,
762 .trigger
= snd_mts64_rawmidi_output_trigger
765 static struct snd_rawmidi_ops snd_mts64_rawmidi_input_ops
= {
766 .open
= snd_mts64_rawmidi_open
,
767 .close
= snd_mts64_rawmidi_close
,
768 .trigger
= snd_mts64_rawmidi_input_trigger
771 /* Create and initialize the rawmidi component */
772 static int __devinit
snd_mts64_rawmidi_create(struct snd_card
*card
)
774 struct mts64
*mts
= card
->private_data
;
775 struct snd_rawmidi
*rmidi
;
776 struct snd_rawmidi_substream
*substream
;
777 struct list_head
*list
;
780 err
= snd_rawmidi_new(card
, CARD_NAME
, 0,
781 MTS64_NUM_OUTPUT_PORTS
,
782 MTS64_NUM_INPUT_PORTS
,
787 rmidi
->private_data
= mts
;
788 strcpy(rmidi
->name
, CARD_NAME
);
789 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_OUTPUT
|
790 SNDRV_RAWMIDI_INFO_INPUT
|
791 SNDRV_RAWMIDI_INFO_DUPLEX
;
795 /* register rawmidi ops */
796 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
,
797 &snd_mts64_rawmidi_output_ops
);
798 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
,
799 &snd_mts64_rawmidi_input_ops
);
801 /* name substreams */
804 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substreams
) {
805 substream
= list_entry(list
, struct snd_rawmidi_substream
, list
);
806 sprintf(substream
->name
,
807 "Miditerminal %d", substream
->number
+1);
811 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substreams
) {
812 substream
= list_entry(list
, struct snd_rawmidi_substream
, list
);
813 mts
->midi_input_substream
[substream
->number
] = substream
;
814 switch(substream
->number
) {
815 case MTS64_SMPTE_SUBSTREAM
:
816 strcpy(substream
->name
, "Miditerminal SMPTE");
819 sprintf(substream
->name
,
820 "Miditerminal %d", substream
->number
+1);
825 err
= snd_mts64_ctl_create(card
, mts
);
830 /*********************************************************************
832 *********************************************************************/
833 static void snd_mts64_interrupt(int irq
, void *private)
835 struct mts64
*mts
= ((struct snd_card
*)private)->private_data
;
838 struct snd_rawmidi_substream
*substream
;
840 spin_lock(&mts
->lock
);
841 ret
= mts64_read(mts
->pardev
->port
);
845 if (status
& MTS64_STAT_PORT
) {
846 mts
->current_midi_input_port
= mts64_map_midi_input(data
);
848 if (mts
->current_midi_input_port
== -1)
850 substream
= mts
->midi_input_substream
[mts
->current_midi_input_port
];
851 if (mts
->mode
[substream
->number
] & MTS64_MODE_INPUT_TRIGGERED
)
852 snd_rawmidi_receive(substream
, &data
, 1);
855 spin_unlock(&mts
->lock
);
858 static int __devinit
snd_mts64_probe_port(struct parport
*p
)
860 struct pardevice
*pardev
;
863 pardev
= parport_register_device(p
, DRIVER_NAME
,
869 if (parport_claim(pardev
)) {
870 parport_unregister_device(pardev
);
874 res
= mts64_probe(p
);
876 parport_release(pardev
);
877 parport_unregister_device(pardev
);
882 static void __devinit
snd_mts64_attach(struct parport
*p
)
884 struct platform_device
*device
;
886 device
= platform_device_alloc(PLATFORM_DRIVER
, device_count
);
890 /* Temporary assignment to forward the parport */
891 platform_set_drvdata(device
, p
);
893 if (platform_device_add(device
) < 0) {
894 platform_device_put(device
);
898 /* Since we dont get the return value of probe
899 * We need to check if device probing succeeded or not */
900 if (!platform_get_drvdata(device
)) {
901 platform_device_unregister(device
);
905 /* register device in global table */
906 platform_devices
[device_count
] = device
;
910 static void snd_mts64_detach(struct parport
*p
)
912 /* nothing to do here */
915 static struct parport_driver mts64_parport_driver
= {
917 .attach
= snd_mts64_attach
,
918 .detach
= snd_mts64_detach
921 /*********************************************************************
923 *********************************************************************/
924 static void snd_mts64_card_private_free(struct snd_card
*card
)
926 struct mts64
*mts
= card
->private_data
;
927 struct pardevice
*pardev
= mts
->pardev
;
930 if (mts
->pardev_claimed
)
931 parport_release(pardev
);
932 parport_unregister_device(pardev
);
938 static int __devinit
snd_mts64_probe(struct platform_device
*pdev
)
940 struct pardevice
*pardev
;
943 struct snd_card
*card
= NULL
;
944 struct mts64
*mts
= NULL
;
947 p
= platform_get_drvdata(pdev
);
948 platform_set_drvdata(pdev
, NULL
);
950 if (dev
>= SNDRV_CARDS
)
954 if ((err
= snd_mts64_probe_port(p
)) < 0)
957 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
, 0);
959 snd_printd("Cannot create card\n");
962 strcpy(card
->driver
, DRIVER_NAME
);
963 strcpy(card
->shortname
, "ESI " CARD_NAME
);
964 sprintf(card
->longname
, "%s at 0x%lx, irq %i",
965 card
->shortname
, p
->base
, p
->irq
);
967 pardev
= parport_register_device(p
, /* port */
968 DRIVER_NAME
, /* name */
971 snd_mts64_interrupt
, /* ISR */
972 PARPORT_DEV_EXCL
, /* flags */
973 (void *)card
); /* private */
974 if (pardev
== NULL
) {
975 snd_printd("Cannot register pardevice\n");
980 if ((err
= snd_mts64_create(card
, pardev
, &mts
)) < 0) {
981 snd_printd("Cannot create main component\n");
982 parport_unregister_device(pardev
);
985 card
->private_data
= mts
;
986 card
->private_free
= snd_mts64_card_private_free
;
988 if ((err
= snd_mts64_rawmidi_create(card
)) < 0) {
989 snd_printd("Creating Rawmidi component failed\n");
994 if (parport_claim(pardev
)) {
995 snd_printd("Cannot claim parport 0x%lx\n", pardev
->port
->base
);
999 mts
->pardev_claimed
= 1;
1002 if ((err
= mts64_device_init(p
)) < 0)
1005 platform_set_drvdata(pdev
, card
);
1007 /* At this point card will be usable */
1008 if ((err
= snd_card_register(card
)) < 0) {
1009 snd_printd("Cannot register card\n");
1013 snd_printk("ESI Miditerminal 4140 on 0x%lx\n", p
->base
);
1017 snd_card_free(card
);
1021 static int __devexit
snd_mts64_remove(struct platform_device
*pdev
)
1023 struct snd_card
*card
= platform_get_drvdata(pdev
);
1026 snd_card_free(card
);
1032 static struct platform_driver snd_mts64_driver
= {
1033 .probe
= snd_mts64_probe
,
1034 .remove
= __devexit_p(snd_mts64_remove
),
1036 .name
= PLATFORM_DRIVER
1040 /*********************************************************************
1042 *********************************************************************/
1043 static void snd_mts64_unregister_all(void)
1047 for (i
= 0; i
< SNDRV_CARDS
; ++i
) {
1048 if (platform_devices
[i
]) {
1049 platform_device_unregister(platform_devices
[i
]);
1050 platform_devices
[i
] = NULL
;
1053 platform_driver_unregister(&snd_mts64_driver
);
1054 parport_unregister_driver(&mts64_parport_driver
);
1057 static int __init
snd_mts64_module_init(void)
1061 if ((err
= platform_driver_register(&snd_mts64_driver
)) < 0)
1064 if (parport_register_driver(&mts64_parport_driver
) != 0) {
1065 platform_driver_unregister(&snd_mts64_driver
);
1069 if (device_count
== 0) {
1070 snd_mts64_unregister_all();
1077 static void __exit
snd_mts64_module_exit(void)
1079 snd_mts64_unregister_all();
1082 module_init(snd_mts64_module_init
);
1083 module_exit(snd_mts64_module_exit
);