2 usb-midi.c -- USB-MIDI driver
5 NAGANO Daisuke <breeze.nagano@nifty.ne.jp>
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, or (at your option)
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
21 This driver is based on:
22 - 'Universal Serial Bus Device Class Definition for MIDI Device'
23 - linux/drivers/sound/es1371.c, linux/drivers/usb/audio.c
24 - alsa/lowlevel/pci/cs64xx.c
28 /* ------------------------------------------------------------------------- */
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/list.h>
35 #include <linux/slab.h>
36 #include <linux/usb.h>
37 #include <linux/poll.h>
38 #include <linux/sound.h>
39 #include <linux/init.h>
40 #include <asm/semaphore.h>
44 /* ------------------------------------------------------------------------- */
46 /* More verbose on syslog */
49 #define MIDI_IN_BUFSIZ 1024
51 #define HAVE_SUPPORT_USB_MIDI_CLASS
53 #undef HAVE_SUPPORT_ALSA
55 /* ------------------------------------------------------------------------- */
57 static int singlebyte = 0;
58 MODULE_PARM(singlebyte,"i");
59 MODULE_PARM_DESC(singlebyte,"Enable sending MIDI messages with single message packet");
61 static int maxdevices = 4;
62 MODULE_PARM(maxdevices,"i");
63 MODULE_PARM_DESC(maxdevices,"Max number of allocatable MIDI device");
65 static int uvendor = -1;
66 MODULE_PARM(uvendor,"i");
67 MODULE_PARM_DESC(uvendor, "The USB Vendor ID of a semi-compliant interface");
69 static int uproduct = -1;
70 MODULE_PARM(uproduct,"i");
71 MODULE_PARM_DESC(uproduct, "The USB Product ID of a semi-compliant interface");
73 static int uinterface = -1;
74 MODULE_PARM(uinterface,"i");
75 MODULE_PARM_DESC(uinterface, "The Interface number of a semi-compliant interface");
78 MODULE_PARM(ualt,"i");
79 MODULE_PARM_DESC(ualt, "The optional alternative setting of a semi-compliant interface");
82 MODULE_PARM(umin,"i");
83 MODULE_PARM_DESC(umin, "The input endpoint of a semi-compliant interface");
85 static int umout = -1;
86 MODULE_PARM(umout,"i");
87 MODULE_PARM_DESC(umout, "The output endpoint of a semi-compliant interface");
89 static int ucable = -1;
90 MODULE_PARM(ucable,"i");
91 MODULE_PARM_DESC(ucable, "The cable number used for a semi-compliant interface");
93 /** Note -- the usb_string() returns only Latin-1 characters.
94 * (unicode chars <= 255). To support Japanese, a unicode16LE-to-EUC or
95 * unicode16LE-to-JIS routine is needed to wrap around usb_get_string().
97 static unsigned short ulangid = 0x0409; /** 0x0411 for Japanese **/
98 MODULE_PARM(ulangid,"h");
99 MODULE_PARM_DESC(ulangid, "The optional preferred USB Language ID for all devices");
101 MODULE_AUTHOR("NAGANO Daisuke <breeze.nagano@nifty.ne.jp>");
102 MODULE_DESCRIPTION("USB-MIDI driver");
103 MODULE_LICENSE("GPL");
105 /* ------------------------------------------------------------------------- */
107 /** MIDIStreaming Class-Specific Interface Descriptor Subtypes **/
109 #define MS_DESCRIPTOR_UNDEFINED 0
111 #define MIDI_IN_JACK 2
112 #define MIDI_OUT_JACK 3
113 /* Spec reads: ELEMENT */
114 #define ELEMENT_DESCRIPTOR 4
116 #define MS_HEADER_LENGTH 7
118 /** MIDIStreaming Class-Specific Endpoint Descriptor Subtypes **/
120 #define DESCRIPTOR_UNDEFINED 0
121 /* Spec reads: MS_GENERAL */
122 #define MS_GENERAL_ENDPOINT 1
124 /** MIDIStreaming MIDI IN and OUT Jack Types **/
126 #define JACK_TYPE_UNDEFINED 0
127 /* Spec reads: EMBEDDED */
128 #define EMBEDDED_JACK 1
129 /* Spec reads: EXTERNAL */
130 #define EXTERNAL_JACK 2
135 usb_midi_state usb_device
142 | | (cable to device pairing magic)
144 usb_midi_dev dev_id (major,minor) == file->private_data
148 /* usb_midi_state: corresponds to a USB-MIDI module */
149 struct usb_midi_state {
150 struct list_head mididev;
152 struct usb_device *usbdev;
154 struct list_head midiDevList;
155 struct list_head inEndpointList;
156 struct list_head outEndpointList;
160 unsigned int count; /* usage counter */
163 /* midi_out_endpoint: corresponds to an output endpoint */
164 struct midi_out_endpoint {
165 struct list_head list;
167 struct usb_device *usbdev;
170 wait_queue_head_t wait;
179 /* midi_in_endpoint: corresponds to an input endpoint */
180 struct midi_in_endpoint {
181 struct list_head list;
183 struct usb_device *usbdev;
186 wait_queue_head_t wait;
188 struct usb_mididev *cables[16]; // cables open for read
189 int readers; // number of cables open for read
192 unsigned char *recvBuf;
194 int urbSubmitted; //FIXME: == readers > 0
197 /* usb_mididev: corresponds to a logical device */
199 struct list_head list;
201 struct usb_midi_state *midi;
206 struct midi_in_endpoint *ep;
209 // as we are pushing data from usb_bulk_read to usb_midi_read,
210 // we need a larger, cyclic buffer here.
211 unsigned char buf[MIDI_IN_BUFSIZ];
218 struct midi_out_endpoint *ep;
221 unsigned char buf[3];
226 unsigned char lastEvent;
232 /** Map the high nybble of MIDI voice messages to number of Message bytes.
233 * High nyble ranges from 0x8 to 0xe
236 static int remains_80e0[] = {
237 3, /** 0x8X Note Off **/
238 3, /** 0x9X Note On **/
239 3, /** 0xAX Poly-key pressure **/
240 3, /** 0xBX Control Change **/
241 2, /** 0xCX Program Change **/
242 2, /** 0xDX Channel pressure **/
243 3 /** 0xEX PitchBend Change **/
246 /** Map the messages to a number of Message bytes.
249 static int remains_f0f6[] = {
254 2, /** 0XF4 (Undefined by MIDI Spec, and subject to change) **/
255 2, /** 0XF5 (Undefined by MIDI Spec, and subject to change) **/
259 /** Map the messages to a CIN (Code Index Number).
262 static int cin_f0ff[] = {
263 4, /** 0xF0 System Exclusive Message Start (special cases may be 6 or 7) */
270 5, /** 0xF7 End of System Exclusive Message (May be 6 or 7) **/
281 /** Map MIDIStreaming Event packet Code Index Number (low nybble of byte 0)
282 * to the number of bytes of valid MIDI data.
284 * CIN of 0 and 1 are NOT USED in MIDIStreaming 1.0.
287 static int cin_to_len[] = {
295 /* ------------------------------------------------------------------------- */
297 static struct list_head mididevs = LIST_HEAD_INIT(mididevs);
299 static DECLARE_MUTEX(open_sem);
300 static DECLARE_WAIT_QUEUE_HEAD(open_wait);
303 /* ------------------------------------------------------------------------- */
305 static void usb_write_callback(struct urb *urb, struct pt_regs *regs)
307 struct midi_out_endpoint *ep = (struct midi_out_endpoint *)urb->context;
309 if ( waitqueue_active( &ep->wait ) )
310 wake_up_interruptible( &ep->wait );
314 static int usb_write( struct midi_out_endpoint *ep, unsigned char *buf, int len )
316 struct usb_device *d;
322 DECLARE_WAITQUEUE(wait,current);
323 init_waitqueue_head(&ep->wait);
326 pipe = usb_sndbulkpipe(d, ep->endpoint);
327 usb_fill_bulk_urb( ep->urb, d, pipe, (unsigned char*)buf, len,
328 usb_write_callback, ep );
330 status = usb_submit_urb(ep->urb, GFP_KERNEL);
333 printk(KERN_ERR "usbmidi: Cannot submit urb (%d)\n",status);
338 add_wait_queue( &ep->wait, &wait );
339 set_current_state( TASK_INTERRUPTIBLE );
341 while( ep->urb->status == -EINPROGRESS ) {
342 if ( maxretry-- < 0 ) {
343 printk(KERN_ERR "usbmidi: usb_bulk_msg timed out\n");
347 interruptible_sleep_on_timeout( &ep->wait, 10 );
349 set_current_state( TASK_RUNNING );
350 remove_wait_queue( &ep->wait, &wait );
357 /** Copy data from URB to In endpoint buf.
358 * Discard if CIN == 0 or CIN = 1.
363 static void usb_bulk_read(struct urb *urb, struct pt_regs *regs)
365 struct midi_in_endpoint *ep = (struct midi_in_endpoint *)(urb->context);
366 unsigned char *data = urb->transfer_buffer;
369 if ( !ep->urbSubmitted ) {
373 if ( (urb->status == 0) && (urb->actual_length > 0) ) {
375 spin_lock( &ep->lock );
377 for(j = 0; j < urb->actual_length; j += 4) {
378 int cin = (data[j]>>0)&0xf;
379 int cab = (data[j]>>4)&0xf;
380 struct usb_mididev *cable = ep->cables[cab];
382 int len = cin_to_len[cin]; /** length of MIDI data **/
383 for (i = 0; i < len; i++) {
384 cable->min.buf[cable->min.bufWrPtr] = data[1+i+j];
385 cable->min.bufWrPtr = (cable->min.bufWrPtr+1)%MIDI_IN_BUFSIZ;
386 if (cable->min.bufRemains < MIDI_IN_BUFSIZ)
387 cable->min.bufRemains += 1;
388 else /** need to drop data **/
389 cable->min.bufRdPtr += (cable->min.bufRdPtr+1)%MIDI_IN_BUFSIZ;
395 spin_unlock ( &ep->lock );
397 wake_up( &ep->wait );
401 /* urb->dev must be reinitialized on 2.4.x kernels */
402 urb->dev = ep->usbdev;
404 urb->actual_length = 0;
405 usb_submit_urb(urb, GFP_ATOMIC);
410 /* ------------------------------------------------------------------------- */
412 /* This routine must be called with spin_lock */
414 /** Wrapper around usb_write().
415 * This routine must be called with spin_lock held on ep.
416 * Called by midiWrite(), putOneMidiEvent(), and usb_midi_write();
418 static int flush_midi_buffer( struct midi_out_endpoint *ep )
422 if ( ep->bufWrPtr > 0 ) {
423 ret = usb_write( ep, ep->buf, ep->bufWrPtr );
431 /* ------------------------------------------------------------------------- */
434 /** Given a MIDI Event, determine size of data to be attached to
437 * Called by midiWrite();
438 * Uses remains_80e0 and remains_f0f6;
440 static int get_remains(int event)
444 if ( event < 0x80 ) {
446 } else if ( event < 0xf0 ) {
447 ret = remains_80e0[((event-0x80)>>4)&0x0f];
448 } else if ( event < 0xf7 ) {
449 ret = remains_f0f6[event-0xf0];
457 /** Given the output MIDI data in the output buffer, computes a reasonable
459 * Called by putOneMidiEvent().
461 static int get_CIN( struct usb_mididev *m )
465 if ( m->mout.buf[0] == 0xf7 ) {
468 else if ( m->mout.buf[1] == 0xf7 ) {
471 else if ( m->mout.buf[2] == 0xf7 ) {
475 if ( m->mout.isInExclusive == 1 ) {
477 } else if ( m->mout.buf[0] < 0x80 ) {
478 /** One byte that we know nothing about. **/
480 } else if ( m->mout.buf[0] < 0xf0 ) {
481 /** MIDI Voice messages 0x8X to 0xEX map to cin 0x8 to 0xE. **/
482 cin = (m->mout.buf[0]>>4)&0x0f;
485 /** Special lookup table exists for real-time events. **/
486 cin = cin_f0ff[m->mout.buf[0]-0xf0];
494 /* ------------------------------------------------------------------------- */
498 /** Move data to USB endpoint buffer.
501 static int put_one_midi_event(struct usb_mididev *m)
505 struct midi_out_endpoint *ep = m->mout.ep;
509 if ( cin > 0x0f || cin < 0 ) {
513 spin_lock_irqsave( &ep->lock, flags );
514 ep->buf[ep->bufWrPtr++] = (m->mout.cableId<<4) | cin;
515 ep->buf[ep->bufWrPtr++] = m->mout.buf[0];
516 ep->buf[ep->bufWrPtr++] = m->mout.buf[1];
517 ep->buf[ep->bufWrPtr++] = m->mout.buf[2];
518 if ( ep->bufWrPtr >= ep->bufSize ) {
519 ret = flush_midi_buffer( ep );
521 spin_unlock_irqrestore( &ep->lock, flags);
523 m->mout.buf[0] = m->mout.buf[1] = m->mout.buf[2] = 0;
529 /** Write the MIDI message v on the midi device.
530 * Called by usb_midi_write();
531 * Responsible for packaging a MIDI data stream into USB-MIDI packets.
534 static int midi_write( struct usb_mididev *m, int v )
537 struct midi_out_endpoint *ep = m->mout.ep;
539 unsigned char c = (unsigned char)v;
540 unsigned char sysrt_buf[4];
542 if ( m->singlebyte != 0 ) {
543 /** Simple code to handle the single-byte USB-MIDI protocol. */
544 spin_lock_irqsave( &ep->lock, flags );
545 if ( ep->bufWrPtr+4 > ep->bufSize ) {
546 ret = flush_midi_buffer( ep );
548 spin_unlock_irqrestore( &ep->lock, flags );
552 ep->buf[ep->bufWrPtr++] = (m->mout.cableId<<4) | 0x0f; /* single byte */
553 ep->buf[ep->bufWrPtr++] = c;
554 ep->buf[ep->bufWrPtr++] = 0;
555 ep->buf[ep->bufWrPtr++] = 0;
556 if ( ep->bufWrPtr >= ep->bufSize ) {
557 ret = flush_midi_buffer( ep );
559 spin_unlock_irqrestore( &ep->lock, flags );
563 /** Normal USB-MIDI protocol begins here. */
565 if ( c > 0xf7 ) { /* system: Realtime messages */
566 /** Realtime messages are written IMMEDIATELY. */
567 sysrt_buf[0] = (m->mout.cableId<<4) | 0x0f;
571 spin_lock_irqsave( &ep->lock, flags );
572 ret = usb_write( ep, sysrt_buf, 4 );
573 spin_unlock_irqrestore( &ep->lock, flags );
574 /* m->mout.lastEvent = 0; */
581 m->mout.lastEvent = c;
582 m->mout.isInExclusive = 0;
583 m->mout.bufRemains = get_remains(c);
584 } else if ( c == 0xf0 ) {
585 /* m->mout.lastEvent = 0; */
586 m->mout.isInExclusive = 1;
587 m->mout.bufRemains = get_remains(c);
588 } else if ( c == 0xf7 && m->mout.isInExclusive == 1 ) {
589 /* m->mout.lastEvent = 0; */
590 m->mout.isInExclusive = 0;
591 m->mout.bufRemains = 1;
592 } else if ( c > 0xf0 ) {
593 /* m->mout.lastEvent = 0; */
594 m->mout.isInExclusive = 0;
595 m->mout.bufRemains = get_remains(c);
598 } else if ( m->mout.bufRemains == 0 && m->mout.isInExclusive == 0 ) {
599 if ( m->mout.lastEvent == 0 ) {
600 return 0; /* discard, waiting for the first event */
603 m->mout.buf[0] = m->mout.lastEvent;
605 m->mout.bufRemains = get_remains(m->mout.lastEvent)-1;
608 m->mout.buf[m->mout.bufPtr++] = c;
609 m->mout.bufRemains--;
610 if ( m->mout.bufRemains == 0 || m->mout.bufPtr >= 3) {
611 ret = put_one_midi_event(m);
618 /* ------------------------------------------------------------------------- */
620 /** Basic operation on /dev/midiXX as registered through struct file_operations.
622 * Basic contract: Used to change the current read/write position in a file.
623 * On success, the non-negative position is reported.
624 * On failure, the negative of an error code is reported.
626 * Because a MIDIStream is not a file, all seek operations are doomed to fail.
629 static loff_t usb_midi_llseek(struct file *file, loff_t offset, int origin)
631 /** Tell user you cannot seek on a PIPE-like device. **/
636 /** Basic operation on /dev/midiXX as registered through struct file_operations.
638 * Basic contract: Block until count bytes have been read or an error occurs.
642 static ssize_t usb_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
644 struct usb_mididev *m = (struct usb_mididev *)file->private_data;
645 struct midi_in_endpoint *ep = m->min.ep;
647 DECLARE_WAITQUEUE(wait, current);
649 if ( ppos != &file->f_pos ) {
652 if ( !access_ok(VERIFY_READ, buffer, count) ) {
659 add_wait_queue( &ep->wait, &wait );
665 cnt = m->min.bufRemains;
671 if ( file->f_flags & O_NONBLOCK ) {
676 __set_current_state(TASK_INTERRUPTIBLE);
678 if (signal_pending(current)) {
688 unsigned long flags; /* used to synchronize access to the endpoint */
689 spin_lock_irqsave( &ep->lock, flags );
690 for (i = 0; i < cnt; i++) {
691 if ( copy_to_user( buffer+i, m->min.buf+m->min.bufRdPtr, 1 ) ) {
696 m->min.bufRdPtr = (m->min.bufRdPtr+1)%MIDI_IN_BUFSIZ;
697 m->min.bufRemains -= 1;
699 spin_unlock_irqrestore( &ep->lock, flags );
709 remove_wait_queue( &ep->wait, &wait );
710 set_current_state(TASK_RUNNING);
716 /** Basic operation on /dev/midiXX as registered through struct file_operations.
718 * Basic Contract: Take MIDI data byte-by-byte and pass it to
719 * writeMidi() which packages MIDI data into USB-MIDI stream.
720 * Then flushMidiData() is called to ensure all bytes have been written
721 * in a timely fashion.
725 static ssize_t usb_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
727 struct usb_mididev *m = (struct usb_mididev *)file->private_data;
729 unsigned long int flags;
731 if ( ppos != &file->f_pos ) {
734 if ( !access_ok(VERIFY_READ, buffer, count) ) {
745 if (copy_from_user((unsigned char *)&c, buffer, 1)) {
750 if( midi_write(m, (int)c) ) {
760 spin_lock_irqsave( &m->mout.ep->lock, flags );
761 if ( flush_midi_buffer(m->mout.ep) < 0 ) {
764 spin_unlock_irqrestore( &m->mout.ep->lock, flags );
769 /** Basic operation on /dev/midiXX as registered through struct file_operations.
771 * Basic contract: Wait (spin) until ready to read or write on the file.
774 static unsigned int usb_midi_poll(struct file *file, struct poll_table_struct *wait)
776 struct usb_mididev *m = (struct usb_mididev *)file->private_data;
777 struct midi_in_endpoint *iep = m->min.ep;
778 struct midi_out_endpoint *oep = m->mout.ep;
780 unsigned int mask = 0;
782 if ( file->f_mode & FMODE_READ ) {
783 poll_wait( file, &iep->wait, wait );
784 spin_lock_irqsave( &iep->lock, flags );
785 if ( m->min.bufRemains > 0 )
786 mask |= POLLIN | POLLRDNORM;
787 spin_unlock_irqrestore( &iep->lock, flags );
790 if ( file->f_mode & FMODE_WRITE ) {
791 poll_wait( file, &oep->wait, wait );
792 spin_lock_irqsave( &oep->lock, flags );
793 if ( oep->bufWrPtr < oep->bufSize )
794 mask |= POLLOUT | POLLWRNORM;
795 spin_unlock_irqrestore( &oep->lock, flags );
802 /** Basic operation on /dev/midiXX as registered through struct file_operations.
804 * Basic contract: This is always the first operation performed on the
805 * device node. If no method is defined, the open succeeds without any
806 * notification given to the module.
810 static int usb_midi_open(struct inode *inode, struct file *file)
812 int minor = iminor(inode);
813 DECLARE_WAITQUEUE(wait, current);
814 struct list_head *devs, *mdevs;
815 struct usb_midi_state *s;
816 struct usb_mididev *m;
821 printk(KERN_INFO "usb-midi: Open minor= %d.\n", minor);
826 for (devs = mididevs.next; devs != &mididevs; devs = devs->next) {
827 s = list_entry(devs, struct usb_midi_state, mididev);
828 for (mdevs = s->midiDevList.next; mdevs != &s->midiDevList; mdevs = mdevs->next) {
829 m = list_entry(mdevs, struct usb_mididev, list);
830 if ( !((m->dev_midi ^ minor) & ~0xf) )
842 if ( !(m->open_mode & file->f_mode) ) {
845 if ( file->f_flags & O_NONBLOCK ) {
849 __set_current_state(TASK_INTERRUPTIBLE);
850 add_wait_queue( &open_wait, &wait );
853 remove_wait_queue( &open_wait, &wait );
854 if ( signal_pending(current) ) {
859 file->private_data = m;
860 spin_lock_irqsave( &s->lock, flags );
862 if ( !(m->open_mode & (FMODE_READ | FMODE_WRITE)) ) {
863 //FIXME: intented semantics unclear here
866 m->min.bufRemains = 0;
867 spin_lock_init(&m->min.ep->lock);
870 m->mout.bufRemains = 0;
871 m->mout.isInExclusive = 0;
872 m->mout.lastEvent = 0;
873 spin_lock_init(&m->mout.ep->lock);
876 if ( (file->f_mode & FMODE_READ) && m->min.ep != NULL ) {
877 unsigned long int flagsep;
878 spin_lock_irqsave( &m->min.ep->lock, flagsep );
879 m->min.ep->cables[m->min.cableId] = m;
880 m->min.ep->readers += 1;
883 m->min.bufRemains = 0;
884 spin_unlock_irqrestore( &m->min.ep->lock, flagsep );
886 if ( !(m->min.ep->urbSubmitted)) {
888 /* urb->dev must be reinitialized on 2.4.x kernels */
889 m->min.ep->urb->dev = m->min.ep->usbdev;
891 if ( usb_submit_urb(m->min.ep->urb, GFP_ATOMIC) ) {
892 printk(KERN_ERR "usbmidi: Cannot submit urb for MIDI-IN\n");
894 m->min.ep->urbSubmitted = 1;
896 m->open_mode |= FMODE_READ;
900 if ( (file->f_mode & FMODE_WRITE) && m->mout.ep != NULL ) {
902 m->mout.bufRemains = 0;
903 m->mout.isInExclusive = 0;
904 m->mout.lastEvent = 0;
905 m->open_mode |= FMODE_WRITE;
909 spin_unlock_irqrestore( &s->lock, flags );
914 /** Changed to prevent extra increments to USE_COUNT. **/
920 printk(KERN_INFO "usb-midi: Open Succeeded. minor= %d.\n", minor);
923 return 0; /** Success. **/
927 /** Basic operation on /dev/midiXX as registered through struct file_operations.
929 * Basic contract: Close an opened file and deallocate anything we allocated.
930 * Like open(), this can be missing. If open set file->private_data,
931 * release() must clear it.
935 static int usb_midi_release(struct inode *inode, struct file *file)
937 struct usb_mididev *m = (struct usb_mididev *)file->private_data;
938 struct usb_midi_state *s = (struct usb_midi_state *)m->midi;
941 printk(KERN_INFO "usb-midi: Close.\n");
946 if ( m->open_mode & FMODE_WRITE ) {
947 m->open_mode &= ~FMODE_WRITE;
948 usb_unlink_urb( m->mout.ep->urb );
951 if ( m->open_mode & FMODE_READ ) {
952 unsigned long int flagsep;
953 spin_lock_irqsave( &m->min.ep->lock, flagsep );
954 m->min.ep->cables[m->min.cableId] = 0; // discard cable
955 m->min.ep->readers -= 1;
956 m->open_mode &= ~FMODE_READ;
957 if ( m->min.ep->readers == 0 &&
958 m->min.ep->urbSubmitted ) {
959 m->min.ep->urbSubmitted = 0;
960 usb_unlink_urb(m->min.ep->urb);
962 spin_unlock_irqrestore( &m->min.ep->lock, flagsep );
970 file->private_data = 0;
974 static struct file_operations usb_midi_fops = {
975 .owner = THIS_MODULE,
976 .llseek = usb_midi_llseek,
977 .read = usb_midi_read,
978 .write = usb_midi_write,
979 .poll = usb_midi_poll,
980 .open = usb_midi_open,
981 .release = usb_midi_release,
984 /* ------------------------------------------------------------------------- */
986 /** Returns filled midi_in_endpoint structure or null on failure.
990 * endPoint - An usb endpoint in the range 0 to 15.
991 * Called by allocUsbMidiDev();
995 static struct midi_in_endpoint *alloc_midi_in_endpoint( struct usb_device *d, int endPoint )
997 struct midi_in_endpoint *ep;
1001 endPoint &= 0x0f; /* Silently force endPoint to lie in range 0 to 15. */
1003 pipe = usb_rcvbulkpipe( d, endPoint );
1004 bufSize = usb_maxpacket( d, pipe, usb_pipein(pipe) );
1005 /* usb_pipein() = ! usb_pipeout() = true for an in Endpoint */
1007 ep = (struct midi_in_endpoint *)kmalloc(sizeof(struct midi_in_endpoint), GFP_KERNEL);
1009 printk(KERN_ERR "usbmidi: no memory for midi in-endpoint\n");
1012 memset( ep, 0, sizeof(struct midi_in_endpoint) );
1013 // this sets cables[] and readers to 0, too.
1014 // for (i=0; i<16; i++) ep->cables[i] = 0; // discard cable
1017 ep->endpoint = endPoint;
1019 ep->recvBuf = (unsigned char *)kmalloc(sizeof(unsigned char)*(bufSize), GFP_KERNEL);
1020 if ( !ep->recvBuf ) {
1021 printk(KERN_ERR "usbmidi: no memory for midi in-endpoint buffer\n");
1026 ep->urb = usb_alloc_urb(0, GFP_KERNEL); /* no ISO */
1028 printk(KERN_ERR "usbmidi: no memory for midi in-endpoint urb\n");
1033 usb_fill_bulk_urb( ep->urb, d,
1034 usb_rcvbulkpipe(d, endPoint),
1035 (unsigned char *)ep->recvBuf, bufSize,
1036 usb_bulk_read, ep );
1038 /* ep->bufRdPtr = 0; */
1039 /* ep->bufWrPtr = 0; */
1040 /* ep->bufRemains = 0; */
1041 /* ep->urbSubmitted = 0; */
1042 ep->recvBufSize = bufSize;
1044 init_waitqueue_head(&ep->wait);
1049 static int remove_midi_in_endpoint( struct midi_in_endpoint *min )
1051 usb_unlink_urb( min->urb );
1052 usb_free_urb( min->urb );
1053 kfree( min->recvBuf );
1059 /** Returns filled midi_out_endpoint structure or null on failure.
1063 * endPoint - An usb endpoint in the range 0 to 15.
1064 * Called by allocUsbMidiDev();
1067 static struct midi_out_endpoint *alloc_midi_out_endpoint( struct usb_device *d, int endPoint )
1069 struct midi_out_endpoint *ep = NULL;
1074 pipe = usb_sndbulkpipe( d, endPoint );
1075 bufSize = usb_maxpacket( d, pipe, usb_pipeout(pipe) );
1077 ep = (struct midi_out_endpoint *)kmalloc(sizeof(struct midi_out_endpoint), GFP_KERNEL);
1079 printk(KERN_ERR "usbmidi: no memory for midi out-endpoint\n");
1082 memset( ep, 0, sizeof(struct midi_out_endpoint) );
1084 ep->endpoint = endPoint;
1085 ep->buf = (unsigned char *)kmalloc(sizeof(unsigned char)*bufSize, GFP_KERNEL);
1087 printk(KERN_ERR "usbmidi: no memory for midi out-endpoint buffer\n");
1092 ep->urb = usb_alloc_urb(0, GFP_KERNEL); /* no ISO */
1094 printk(KERN_ERR "usbmidi: no memory for midi out-endpoint urb\n");
1100 ep->bufSize = bufSize;
1101 /* ep->bufWrPtr = 0; */
1103 init_waitqueue_head(&ep->wait);
1109 static int remove_midi_out_endpoint( struct midi_out_endpoint *mout )
1111 usb_unlink_urb( mout->urb );
1112 usb_free_urb( mout->urb );
1120 /** Returns a filled usb_mididev structure, registered as a Linux MIDI device.
1122 * Returns null if memory is not available or the device cannot be registered.
1123 * Called by allocUsbMidiDev();
1126 static struct usb_mididev *allocMidiDev(
1127 struct usb_midi_state *s,
1128 struct midi_in_endpoint *min,
1129 struct midi_out_endpoint *mout,
1133 struct usb_mididev *m;
1135 m = (struct usb_mididev *)kmalloc(sizeof(struct usb_mididev), GFP_KERNEL);
1137 printk(KERN_ERR "usbmidi: no memory for midi device\n");
1141 memset(m, 0, sizeof(struct usb_mididev));
1143 if ((m->dev_midi = register_sound_midi(&usb_midi_fops, -1)) < 0) {
1144 printk(KERN_ERR "usbmidi: cannot register midi device\n");
1150 /* m->open_mode = 0; */
1154 m->min.ep->usbdev = s->usbdev;
1155 m->min.cableId = inCableId;
1157 /* m->min.bufPtr = 0; */
1158 /* m->min.bufRemains = 0; */
1162 m->mout.ep->usbdev = s->usbdev;
1163 m->mout.cableId = outCableId;
1165 /* m->mout.bufPtr = 0; */
1166 /* m->mout.bufRemains = 0; */
1167 /* m->mout.isInExclusive = 0; */
1168 /* m->mout.lastEvent = 0; */
1170 m->singlebyte = singlebyte;
1176 static void release_midi_device( struct usb_midi_state *s )
1178 struct usb_mididev *m;
1179 struct midi_in_endpoint *min;
1180 struct midi_out_endpoint *mout;
1182 if ( s->count > 0 ) {
1187 wake_up( &open_wait );
1189 while(!list_empty(&s->inEndpointList)) {
1190 min = list_entry(s->inEndpointList.next, struct midi_in_endpoint, list);
1191 list_del(&min->list);
1192 remove_midi_in_endpoint(min);
1195 while(!list_empty(&s->outEndpointList)) {
1196 mout = list_entry(s->outEndpointList.next, struct midi_out_endpoint, list);
1197 list_del(&mout->list);
1198 remove_midi_out_endpoint(mout);
1201 while(!list_empty(&s->midiDevList)) {
1202 m = list_entry(s->midiDevList.next, struct usb_mididev, list);
1213 /* ------------------------------------------------------------------------- */
1215 /** Utility routine to find a descriptor in a dump of many descriptors.
1216 * Returns start of descriptor or NULL if not found.
1217 * descStart pointer to list of interfaces.
1218 * descLength length (in bytes) of dump
1219 * after (ignored if NULL) this routine returns only descriptors after "after"
1220 * dtype (mandatory) The descriptor type.
1221 * iface (ignored if -1) returns descriptor at/following given interface
1222 * altSetting (ignored if -1) returns descriptor at/following given altSetting
1225 * Called by parseDescriptor(), find_csinterface_descriptor();
1228 static void *find_descriptor( void *descStart, unsigned int descLength, void *after, unsigned char dtype, int iface, int altSetting )
1230 unsigned char *p, *end, *next;
1231 int interfaceNumber = -1, altSet = -1;
1234 end = p + descLength;
1241 if ( p[1] == USB_DT_INTERFACE ) {
1242 if ( p[0] < USB_DT_INTERFACE_SIZE )
1244 interfaceNumber = p[2];
1247 if ( p[1] == dtype &&
1248 ( !after || ( p > (unsigned char *)after) ) &&
1249 ( ( iface == -1) || (iface == interfaceNumber) ) &&
1250 ( (altSetting == -1) || (altSetting == altSet) )) {
1258 /** Utility to find a class-specific interface descriptor.
1259 * dsubtype is a descriptor subtype
1260 * Called by parseDescriptor();
1262 static void *find_csinterface_descriptor(void *descStart, unsigned int descLength, void *after, u8 dsubtype, int iface, int altSetting)
1266 p = find_descriptor( descStart, descLength, after, USB_DT_CS_INTERFACE, iface, altSetting );
1268 if ( p[0] >= 3 && p[2] == dsubtype )
1270 p = find_descriptor( descStart, descLength, p, USB_DT_CS_INTERFACE,
1271 iface, altSetting );
1277 /** The magic of making a new usb_midi_device from config happens here.
1279 * The caller is responsible for free-ing this return value (if not NULL).
1282 static struct usb_midi_device *parse_descriptor( struct usb_device *d, unsigned char *buffer, int bufSize, unsigned int ifnum , unsigned int altSetting, int quirks)
1284 struct usb_midi_device *u;
1287 unsigned char *next;
1290 unsigned long longBits;
1291 int pins, nbytes, offset, shift, jack;
1292 #ifdef HAVE_JACK_STRINGS
1293 /** Jacks can have associated names. **/
1294 unsigned char jack2string[256];
1298 /* find audiocontrol interface */
1299 p1 = find_csinterface_descriptor( buffer, bufSize, NULL,
1300 MS_HEADER, ifnum, altSetting);
1306 if ( p1[0] < MS_HEADER_LENGTH ) {
1310 /* Assume success. Since the device corresponds to USB-MIDI spec, we assume
1311 that the rest of the USB 2.0 spec is obeyed. */
1313 u = (struct usb_midi_device *)kmalloc( sizeof(struct usb_midi_device), GFP_KERNEL );
1318 u->idVendor = d->descriptor.idVendor;
1319 u->idProduct = d->descriptor.idProduct;
1320 u->interface = ifnum;
1321 u->altSetting = altSetting;
1322 u->in[0].endpoint = -1;
1323 u->in[0].cableId = -1;
1324 u->out[0].endpoint = -1;
1325 u->out[0].cableId = -1;
1328 printk(KERN_INFO "usb-midi: Found MIDIStreaming device corresponding to Release %d.%02d of spec.\n",
1329 (p1[4] >> 4) * 10 + (p1[4] & 0x0f ),
1330 (p1[3] >> 4) * 10 + (p1[3] & 0x0f )
1333 length = p1[5] | (p1[6] << 8);
1335 #ifdef HAVE_JACK_STRINGS
1336 memset(jack2string, 0, sizeof(unsigned char) * 256);
1340 for (p2 = p1 + p1[0]; length > 0; p2 = next) {
1346 if (p2[1] != USB_DT_CS_INTERFACE)
1348 if (p2[2] == MIDI_IN_JACK && p2[0] >= 6 ) {
1350 #ifdef HAVE_JACK_STRINGS
1351 jack2string[jack] = p2[5];
1353 printk(KERN_INFO "usb-midi: Found IN Jack 0x%02x %s\n",
1354 jack, (p2[3] == EMBEDDED_JACK)?"EMBEDDED":"EXTERNAL" );
1355 } else if ( p2[2] == MIDI_OUT_JACK && p2[0] >= 6) {
1357 if ( p2[0] < (6 + 2 * pins) )
1360 #ifdef HAVE_JACK_STRINGS
1361 jack2string[jack] = p2[5 + 2 * pins];
1363 printk(KERN_INFO "usb-midi: Found OUT Jack 0x%02x %s, %d pins\n",
1364 jack, (p2[3] == EMBEDDED_JACK)?"EMBEDDED":"EXTERNAL", pins );
1365 } else if ( p2[2] == ELEMENT_DESCRIPTOR && p2[0] >= 10) {
1367 if ( p2[0] < (9 + 2 * pins ) )
1369 nbytes = p2[8 + 2 * pins ];
1370 if ( p2[0] < (10 + 2 * pins + nbytes) )
1373 for ( offset = 0, shift = 0; offset < nbytes && offset < 8; offset ++, shift += 8) {
1374 longBits |= ((long)(p2[9 + 2 * pins + offset])) << shift;
1377 #ifdef HAVE_JACK_STRINGS
1378 jack2string[jack] = p2[9 + 2 * pins + nbytes];
1380 printk(KERN_INFO "usb-midi: Found ELEMENT 0x%02x, %d/%d pins in/out, bits: 0x%016lx\n",
1381 jack, pins, (int)(p2[5 + 2 * pins]), (long)longBits );
1392 for (p1 = find_descriptor(buffer, bufSize, NULL, USB_DT_ENDPOINT,
1393 ifnum, altSetting ); p1; p1 = next ) {
1394 next = find_descriptor(buffer, bufSize, p1, USB_DT_ENDPOINT,
1395 ifnum, altSetting );
1396 p2 = find_descriptor(buffer, bufSize, p1, USB_DT_CS_ENDPOINT,
1397 ifnum, altSetting );
1399 if ( p2 && next && ( p2 > next ) )
1402 if ( p1[0] < 9 || !p2 || p2[0] < 4 )
1405 if ( (p1[2] & 0x80) == 0x80 ) {
1407 pins = p2[3]; /* not pins -- actually "cables" */
1410 u->in[iep].endpoint = p1[2];
1411 u->in[iep].cableId = ( 1 << pins ) - 1;
1412 if ( u->in[iep].cableId )
1415 u->in[iep].endpoint = -1;
1416 u->in[iep].cableId = -1;
1421 pins = p2[3]; /* not pins -- actually "cables" */
1424 u->out[oep].endpoint = p1[2];
1425 u->out[oep].cableId = ( 1 << pins ) - 1;
1426 if ( u->out[oep].cableId )
1429 u->out[oep].endpoint = -1;
1430 u->out[oep].cableId = -1;
1436 } else if (quirks==1) {
1438 for (p1 = find_descriptor(buffer, bufSize, NULL, USB_DT_ENDPOINT,
1439 ifnum, altSetting ); p1; p1 = next ) {
1440 next = find_descriptor(buffer, bufSize, p1, USB_DT_ENDPOINT,
1441 ifnum, altSetting );
1446 if ( (p1[2] & 0x80) == 0x80 ) {
1451 u->in[iep].endpoint = p1[2];
1452 u->in[iep].cableId = ( 1 << pins ) - 1;
1453 if ( u->in[iep].cableId )
1456 u->in[iep].endpoint = -1;
1457 u->in[iep].cableId = -1;
1465 u->out[oep].endpoint = p1[2];
1466 u->out[oep].cableId = ( 1 << pins ) - 1;
1467 if ( u->out[oep].cableId )
1470 u->out[oep].endpoint = -1;
1471 u->out[oep].cableId = -1;
1479 if ( !iep && ! oep ) {
1490 /* ------------------------------------------------------------------------- */
1492 /** Returns number between 0 and 16.
1495 static int on_bits( unsigned short v )
1500 for ( i=0 ; i<16 ; i++ ) {
1509 /** USB-device will be interrogated for altSetting.
1511 * Returns negative on error.
1512 * Called by allocUsbMidiDev();
1516 static int get_alt_setting( struct usb_device *d, int ifnum )
1519 struct usb_interface *iface;
1520 struct usb_host_interface *interface;
1521 struct usb_endpoint_descriptor *ep;
1525 iface = usb_ifnum_to_if( d, ifnum );
1526 alts = iface->num_altsetting;
1528 for ( alt=0 ; alt<alts ; alt++ ) {
1529 interface = &iface->altsetting[alt];
1533 for ( i=0 ; i<interface->desc.bNumEndpoints ; i++ ) {
1534 ep = &interface->endpoint[i].desc;
1535 if ( (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ) {
1538 if ( (ep->bEndpointAddress & USB_DIR_IN) && epin < 0 ) {
1540 } else if ( epout < 0 ) {
1543 if ( epin >= 0 && epout >= 0 ) {
1544 return interface->desc.bAlternateSetting;
1553 /* ------------------------------------------------------------------------- */
1556 /** Returns 0 if successful in allocating and registering internal structures.
1557 * Returns negative on failure.
1558 * Calls allocMidiDev which additionally registers /dev/midiXX devices.
1559 * Writes messages on success to indicate which /dev/midiXX is which physical
1563 static int alloc_usb_midi_device( struct usb_device *d, struct usb_midi_state *s, struct usb_midi_device *u )
1565 struct usb_mididev **mdevs=NULL;
1566 struct midi_in_endpoint *mins[15], *min;
1567 struct midi_out_endpoint *mouts[15], *mout;
1568 int inDevs=0, outDevs=0;
1569 int inEndpoints=0, outEndpoints=0;
1570 int inEndpoint, outEndpoint;
1571 int inCableId, outCableId;
1576 /* Obtain altSetting or die.. */
1577 alt = u->altSetting;
1579 alt = get_alt_setting( d, u->interface );
1584 /* Configure interface */
1585 if ( usb_set_interface( d, u->interface, alt ) < 0 ) {
1589 for ( i = 0 ; i < 15 ; i++ ) {
1594 /* Begin Allocation */
1595 while( inEndpoints < 15
1596 && inDevs < maxdevices
1597 && u->in[inEndpoints].cableId >= 0 ) {
1598 inDevs += on_bits((unsigned short)u->in[inEndpoints].cableId);
1599 mins[inEndpoints] = alloc_midi_in_endpoint( d, u->in[inEndpoints].endpoint );
1600 if ( mins[inEndpoints] == NULL )
1605 while( outEndpoints < 15
1606 && outDevs < maxdevices
1607 && u->out[outEndpoints].cableId >= 0 ) {
1608 outDevs += on_bits((unsigned short)u->out[outEndpoints].cableId);
1609 mouts[outEndpoints] = alloc_midi_out_endpoint( d, u->out[outEndpoints].endpoint );
1610 if ( mouts[outEndpoints] == NULL )
1615 devices = inDevs > outDevs ? inDevs : outDevs;
1616 devices = maxdevices > devices ? devices : maxdevices;
1618 /* obtain space for device name (iProduct) if not known. */
1619 if ( ! u->deviceName ) {
1620 mdevs = (struct usb_mididev **)
1621 kmalloc(sizeof(struct usb_mididevs *)*devices
1622 + sizeof(char) * 256, GFP_KERNEL);
1624 mdevs = (struct usb_mididev **)
1625 kmalloc(sizeof(struct usb_mididevs *)*devices, GFP_KERNEL);
1633 for ( i=0 ; i<devices ; i++ ) {
1637 /* obtain device name (iProduct) if not known. */
1638 if ( ! u->deviceName ) {
1639 u->deviceName = (char *) (mdevs + devices);
1640 if ( ! d->have_langid && d->descriptor.iProduct) {
1641 alt = usb_get_string(d, 0, 0, u->deviceName, 250);
1643 printk(KERN_INFO "error getting string descriptor 0 (error=%d)\n", alt);
1644 } else if (u->deviceName[0] < 4) {
1645 printk(KERN_INFO "string descriptor 0 too short (length = %d)\n", alt);
1647 printk(KERN_INFO "string descriptor 0 found (length = %d)\n", alt);
1648 for(; alt >= 4; alt -= 2) {
1649 i = u->deviceName[alt-2] | (u->deviceName[alt-1]<< 8);
1650 printk(KERN_INFO "usb-midi: langid(%d) 0x%04x\n",
1652 if ( ( ( i ^ ulangid ) & 0xff ) == 0 ) {
1654 d->string_langid = i;
1655 printk(KERN_INFO "usb-midi: langid(match) 0x%04x\n", i);
1662 u->deviceName[0] = (char) 0;
1663 if (d->descriptor.iProduct) {
1664 printk(KERN_INFO "usb-midi: fetchString(%d)\n", d->descriptor.iProduct);
1665 alt = usb_string(d, d->descriptor.iProduct, u->deviceName, 255);
1667 u->deviceName[0] = (char) 0;
1669 printk(KERN_INFO "usb-midi: fetchString = %d\n", alt);
1672 if ( !u->deviceName[0] ) {
1673 if ( d->descriptor.idVendor == USB_VENDOR_ID_ROLAND ) {
1674 strcpy(u->deviceName, "Unknown Roland");
1675 } else if ( d->descriptor.idVendor == USB_VENDOR_ID_STEINBERG ) {
1676 strcpy(u->deviceName, "Unknown Steinberg");
1677 } else if ( d->descriptor.idVendor == USB_VENDOR_ID_YAMAHA ) {
1678 strcpy(u->deviceName, "Unknown Yamaha");
1680 strcpy(u->deviceName, "Unknown");
1685 inEndpoint = 0; inCableId = -1;
1686 outEndpoint = 0; outCableId = -1;
1688 for ( i=0 ; i<devices ; i++ ) {
1689 for ( inCableId ++ ;
1692 && !(u->in[inEndpoint].cableId & (1<<inCableId)) ;
1694 if ( inCableId >= 16 ) {
1699 min = mins[inEndpoint];
1700 for ( outCableId ++ ;
1702 && mouts[outEndpoint]
1703 && !(u->out[outEndpoint].cableId & (1<<outCableId)) ;
1705 if ( outCableId >= 16 ) {
1710 mout = mouts[outEndpoint];
1712 mdevs[i] = allocMidiDev( s, min, mout, inCableId, outCableId );
1713 if ( mdevs[i] == NULL )
1719 for ( i=0 ; i<devices ; i++ ) {
1720 list_add_tail( &mdevs[i]->list, &s->midiDevList );
1722 for ( i=0 ; i<inEndpoints ; i++ ) {
1723 list_add_tail( &mins[i]->list, &s->inEndpointList );
1725 for ( i=0 ; i<outEndpoints ; i++ ) {
1726 list_add_tail( &mouts[i]->list, &s->outEndpointList );
1729 printk(KERN_INFO "usbmidi: found [ %s ] (0x%04x:0x%04x), attached:\n", u->deviceName, u->idVendor, u->idProduct );
1730 for ( i=0 ; i<devices ; i++ ) {
1731 int dm = (mdevs[i]->dev_midi-2)>>4;
1732 if ( mdevs[i]->mout.ep != NULL && mdevs[i]->min.ep != NULL ) {
1733 printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%2d) out (ep:%02x cid:%2d bufsiz:%2d)\n",
1735 mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize,
1736 mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize);
1737 } else if ( mdevs[i]->min.ep != NULL ) {
1738 printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%02d)\n",
1740 mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize);
1741 } else if ( mdevs[i]->mout.ep != NULL ) {
1742 printk(KERN_INFO "usbmidi: /dev/midi%02d: out (ep:%02x cid:%2d bufsiz:%02d)\n",
1744 mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize);
1752 if ( mdevs != NULL ) {
1753 for ( i=0 ; i<devices ; i++ ) {
1754 if ( mdevs[i] != NULL ) {
1755 unregister_sound_midi( mdevs[i]->dev_midi );
1762 for ( i=0 ; i<15 ; i++ ) {
1763 if ( mins[i] != NULL ) {
1764 remove_midi_in_endpoint( mins[i] );
1766 if ( mouts[i] != NULL ) {
1767 remove_midi_out_endpoint( mouts[i] );
1774 /* ------------------------------------------------------------------------- */
1776 /** Attempt to scan YAMAHA's device descriptor and detect correct values of
1778 * Return 0 on succes, negative on failure.
1779 * Called by usb_midi_probe();
1782 static int detect_yamaha_device( struct usb_device *d,
1783 struct usb_interface *iface, unsigned int ifnum,
1784 struct usb_midi_state *s)
1786 struct usb_host_interface *interface;
1787 struct usb_midi_device *u;
1788 unsigned char *buffer;
1794 if (d->descriptor.idVendor != USB_VENDOR_ID_YAMAHA) {
1798 for ( i=0 ; i < iface->num_altsetting; i++ ) {
1799 interface = iface->altsetting + i;
1801 if ( interface->desc.bInterfaceClass != 255 ||
1802 interface->desc.bInterfaceSubClass != 0 )
1804 alts = interface->desc.bAlternateSetting;
1810 printk(KERN_INFO "usb-midi: Found YAMAHA USB-MIDI device on dev %04x:%04x, iface %d\n",
1811 d->descriptor.idVendor, d->descriptor.idProduct, ifnum);
1813 i = d->actconfig - d->config;
1814 buffer = d->rawdescriptors[i];
1815 bufSize = d->actconfig->desc.wTotalLength;
1817 u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 1);
1822 ret = alloc_usb_midi_device( d, s, u );
1830 /** Scan table of known devices which are only partially compliant with
1831 * the MIDIStreaming specification.
1832 * Called by usb_midi_probe();
1836 static int detect_vendor_specific_device( struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s )
1838 struct usb_midi_device *u;
1842 for ( i=0; i<VENDOR_SPECIFIC_USB_MIDI_DEVICES ; i++ ) {
1843 u=&(usb_midi_devices[i]);
1845 if ( d->descriptor.idVendor != u->idVendor ||
1846 d->descriptor.idProduct != u->idProduct ||
1847 ifnum != u->interface )
1850 ret = alloc_usb_midi_device( d, s, u );
1858 /** Attempt to match any config of an interface to a MIDISTREAMING interface.
1859 * Returns 0 on success, negative on failure.
1860 * Called by usb_midi_probe();
1862 static int detect_midi_subclass(struct usb_device *d,
1863 struct usb_interface *iface, unsigned int ifnum,
1864 struct usb_midi_state *s)
1866 struct usb_host_interface *interface;
1867 struct usb_midi_device *u;
1868 unsigned char *buffer;
1874 for ( i=0 ; i < iface->num_altsetting; i++ ) {
1875 interface = iface->altsetting + i;
1877 if ( interface->desc.bInterfaceClass != USB_CLASS_AUDIO ||
1878 interface->desc.bInterfaceSubClass != USB_SUBCLASS_MIDISTREAMING )
1880 alts = interface->desc.bAlternateSetting;
1886 printk(KERN_INFO "usb-midi: Found MIDISTREAMING on dev %04x:%04x, iface %d\n",
1887 d->descriptor.idVendor, d->descriptor.idProduct, ifnum);
1890 /* From USB Spec v2.0, Section 9.5.
1891 If the class or vendor specific descriptors use the same format
1892 as standard descriptors (e.g., start with a length byte and
1893 followed by a type byte), they must be returned interleaved with
1894 standard descriptors in the configuration information returned by
1895 a GetDescriptor(Configuration) request. In this case, the class
1896 or vendor-specific descriptors must follow a related standard
1897 descriptor they modify or extend.
1900 i = d->actconfig - d->config;
1901 buffer = d->rawdescriptors[i];
1902 bufSize = d->actconfig->desc.wTotalLength;
1904 u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 0);
1909 ret = alloc_usb_midi_device( d, s, u );
1917 /** When user has requested a specific device, match it exactly.
1919 * Uses uvendor, uproduct, uinterface, ualt, umin, umout and ucable.
1920 * Called by usb_midi_probe();
1923 static int detect_by_hand(struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s)
1925 struct usb_midi_device u;
1927 if ( d->descriptor.idVendor != uvendor ||
1928 d->descriptor.idProduct != uproduct ||
1929 ifnum != uinterface ) {
1936 if ( umin < 0 || umin > 15 )
1937 umin = 0x01 | USB_DIR_IN;
1938 if ( umout < 0 || umout > 15 )
1940 if ( ucable < 0 || ucable > 15 )
1943 u.deviceName = 0; /* A flag for alloc_usb_midi_device to get device name
1945 u.idVendor = uvendor;
1946 u.idProduct = uproduct;
1947 u.interface = uinterface;
1948 u.altSetting = ualt;
1950 u.in[0].endpoint = umin;
1951 u.in[0].cableId = (1<<ucable);
1953 u.out[0].endpoint = umout;
1954 u.out[0].cableId = (1<<ucable);
1956 return alloc_usb_midi_device( d, s, &u );
1961 /* ------------------------------------------------------------------------- */
1963 static int usb_midi_probe(struct usb_interface *intf,
1964 const struct usb_device_id *id)
1966 struct usb_midi_state *s;
1967 struct usb_device *dev = interface_to_usbdev(intf);
1968 int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1970 s = (struct usb_midi_state *)kmalloc(sizeof(struct usb_midi_state), GFP_KERNEL);
1974 memset( s, 0, sizeof(struct usb_midi_state) );
1975 INIT_LIST_HEAD(&s->midiDevList);
1976 INIT_LIST_HEAD(&s->inEndpointList);
1977 INIT_LIST_HEAD(&s->outEndpointList);
1980 spin_lock_init(&s->lock);
1983 detect_by_hand( dev, ifnum, s ) &&
1984 detect_midi_subclass( dev, intf, ifnum, s ) &&
1985 detect_vendor_specific_device( dev, ifnum, s ) &&
1986 detect_yamaha_device( dev, intf, ifnum, s) ) {
1992 list_add_tail(&s->mididev, &mididevs);
1995 usb_set_intfdata (intf, s);
2000 static void usb_midi_disconnect(struct usb_interface *intf)
2002 struct usb_midi_state *s = usb_get_intfdata (intf);
2003 struct list_head *list;
2004 struct usb_mididev *m;
2009 if ( s == (struct usb_midi_state *)-1 ) {
2016 list_del(&s->mididev);
2017 INIT_LIST_HEAD(&s->mididev);
2019 usb_set_intfdata (intf, NULL);
2021 for ( list = s->midiDevList.next; list != &s->midiDevList; list = list->next ) {
2022 m = list_entry(list, struct usb_mididev, list);
2023 wake_up(&(m->min.ep->wait));
2024 wake_up(&(m->mout.ep->wait));
2025 if ( m->dev_midi >= 0 ) {
2026 unregister_sound_midi(m->dev_midi);
2030 release_midi_device(s);
2031 wake_up(&open_wait);
2034 /* we want to look at all devices by hand */
2035 static struct usb_device_id id_table[] = {
2036 {.driver_info = 42},
2040 static struct usb_driver usb_midi_driver = {
2041 .owner = THIS_MODULE,
2043 .probe = usb_midi_probe,
2044 .disconnect = usb_midi_disconnect,
2045 .id_table = id_table,
2048 /* ------------------------------------------------------------------------- */
2050 static int __init usb_midi_init(void)
2052 return usb_register(&usb_midi_driver);
2055 static void __exit usb_midi_exit(void)
2057 usb_deregister(&usb_midi_driver);
2060 module_init(usb_midi_init) ;
2061 module_exit(usb_midi_exit) ;
2063 #ifdef HAVE_ALSA_SUPPORT
2064 #define SNDRV_MAIN_OBJECT_FILE
2065 #include "../../include/driver.h"
2066 #include "../../include/control.h"
2067 #include "../../include/info.h"
2068 #include "../../include/cs46xx.h"
2070 /* ------------------------------------------------------------------------- */
2072 static int snd_usbmidi_input_close(snd_rawmidi_substream_t * substream)
2077 static int snd_usbmidi_input_open(snd_rawmidi_substream_t * substream )
2082 static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t * substream, int up)
2088 /* ------------------------------------------------------------------------- */
2090 static int snd_usbmidi_output_close(snd_rawmidi_substream_t * substream)
2095 static int snd_usbmidi_output_open(snd_rawmidi_substream_t * substream)
2100 static void snd_usb_midi_output_trigger(snd_rawmidi_substream_t * substream,
2106 /* ------------------------------------------------------------------------- */
2108 static snd_rawmidi_ops_t snd_usbmidi_output =
2110 .open = snd_usbmidi_output_open,
2111 .close = snd_usbmidi_output_close,
2112 .trigger = snd_usbmidi_output_trigger,
2114 static snd_rawmidi_ops_t snd_usbmidi_input =
2116 .open = snd_usbmidi_input_open,
2117 .close = snd_usbmidi_input_close,
2118 .trigger = snd_usbmidi_input_trigger,
2121 int snd_usbmidi_midi(cs46xx_t *chip, int device, snd_rawmidi_t **rrawmidi)
2123 snd_rawmidi_t *rmidi;
2128 if ((err = snd_rawmidi_new(chip->card, "USB-MIDI", device, 1, 1, &rmidi)) < 0)
2130 strcpy(rmidi->name, "USB-MIDI");
2132 snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output );
2133 snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usbmidi_input );
2135 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
2137 rmidi->private_data = chip;
2138 chip->rmidi = rmidi;
2145 int snd_usbmidi_create( snd_card_t * card,
2146 struct pci_dev * pci,
2147 usbmidi_t ** rchip )
2151 snd_region_t *region;
2152 static snd_device_opt_t ops = {
2153 .dev_free = snd_usbmidi_dev_free,
2157 chip = snd_magic_kcalloc( usbmidi_t, 0, GFP_KERNEL );
2162 EXPORT_SYMBOL(snd_usbmidi_create);
2163 EXPORT_SYMBOL(snd_usbmidi_midi);
2164 #endif /* HAVE_ALSA_SUPPORT */