URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [usb-midi.c] - Rev 1765
Compare with Previous | Blame | View Log
/* usb-midi.c -- USB-MIDI driver Copyright (C) 2001 NAGANO Daisuke <breeze.nagano@nifty.ne.jp> This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. This driver is based on: - 'Universal Serial Bus Device Class Definition for MIDI Device' - linux/drivers/sound/es1371.c, linux/drivers/usb/audio.c - alsa/lowlevel/pci/cs64xx.c - umidi.c for NetBSD */ /* ------------------------------------------------------------------------- */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/sched.h> #include <linux/list.h> #include <linux/slab.h> #include <linux/wrapper.h> #include <linux/usb.h> #include <linux/poll.h> #include <linux/sound.h> #include <linux/init.h> #include <asm/semaphore.h> /** This declaration is missing from linux/usb.h **/ extern int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size); #include "usb-midi.h" /* ------------------------------------------------------------------------- */ /* More verbose on syslog */ #undef MIDI_DEBUG #define MIDI_IN_BUFSIZ 1024 #define HAVE_SUPPORT_USB_MIDI_CLASS #undef HAVE_SUPPORT_ALSA #undef MOD_INC_EACH_PROBE /* ------------------------------------------------------------------------- */ static int singlebyte = 0; MODULE_PARM(singlebyte,"i"); MODULE_PARM_DESC(singlebyte,"Enable sending MIDI messages with single message packet"); static int maxdevices = 4; MODULE_PARM(maxdevices,"i"); MODULE_PARM_DESC(maxdevices,"Max number of allocatable MIDI device"); static int uvendor = -1; MODULE_PARM(uvendor,"i"); MODULE_PARM_DESC(uvendor, "The USB Vendor ID of a semi-compliant interface"); static int uproduct = -1; MODULE_PARM(uproduct,"i"); MODULE_PARM_DESC(uproduct, "The USB Product ID of a semi-compliant interface"); static int uinterface = -1; MODULE_PARM(uinterface,"i"); MODULE_PARM_DESC(uinterface, "The Interface number of a semi-compliant interface"); static int ualt = -1; MODULE_PARM(ualt,"i"); MODULE_PARM_DESC(ualt, "The optional alternative setting of a semi-compliant interface"); static int umin = -1; MODULE_PARM(umin,"i"); MODULE_PARM_DESC(umin, "The input endpoint of a semi-compliant interface"); static int umout = -1; MODULE_PARM(umout,"i"); MODULE_PARM_DESC(umout, "The output endpoint of a semi-compliant interface"); static int ucable = -1; MODULE_PARM(ucable,"i"); MODULE_PARM_DESC(ucable, "The cable number used for a semi-compliant interface"); /** Note -- the usb_string() returns only Latin-1 characters. * (unicode chars <= 255). To support Japanese, a unicode16LE-to-EUC or * unicode16LE-to-JIS routine is needed to wrap around usb_get_string(). **/ static unsigned short ulangid = 0x0409; /** 0x0411 for Japanese **/ MODULE_PARM(ulangid,"h"); MODULE_PARM_DESC(ulangid, "The optional preferred USB Language ID for all devices"); MODULE_AUTHOR("NAGANO Daisuke <breeze.nagano@nifty.ne.jp>"); MODULE_DESCRIPTION("USB-MIDI driver"); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,14) MODULE_LICENSE("GPL"); #endif /* ------------------------------------------------------------------------- */ /** MIDIStreaming Class-Specific Interface Descriptor Subtypes **/ #define MS_DESCRIPTOR_UNDEFINED 0 #define MS_HEADER 1 #define MIDI_IN_JACK 2 #define MIDI_OUT_JACK 3 /* Spec reads: ELEMENT */ #define ELEMENT_DESCRIPTOR 4 #define MS_HEADER_LENGTH 7 /** MIDIStreaming Class-Specific Endpoint Descriptor Subtypes **/ #define DESCRIPTOR_UNDEFINED 0 /* Spec reads: MS_GENERAL */ #define MS_GENERAL_ENDPOINT 1 /** MIDIStreaming MIDI IN and OUT Jack Types **/ #define JACK_TYPE_UNDEFINED 0 /* Spec reads: EMBEDDED */ #define EMBEDDED_JACK 1 /* Spec reads: EXTERNAL */ #define EXTERNAL_JACK 2 /* structure summary usb_midi_state usb_device | | *| *| per ep in_ep out_ep | | *| *| per cable min mout | | (cable to device pairing magic) | | usb_midi_dev dev_id (major,minor) == file->private_data */ /* usb_midi_state: corresponds to a USB-MIDI module */ struct usb_midi_state { struct list_head mididev; struct usb_device *usbdev; struct list_head midiDevList; struct list_head inEndpointList; struct list_head outEndpointList; spinlock_t lock; unsigned int count; /* usage counter */ }; /* midi_out_endpoint: corresponds to an output endpoint */ struct midi_out_endpoint { struct list_head list; struct usb_device *usbdev; int endpoint; spinlock_t lock; wait_queue_head_t wait; unsigned char *buf; int bufWrPtr; int bufSize; struct urb *urb; }; /* midi_in_endpoint: corresponds to an input endpoint */ struct midi_in_endpoint { struct list_head list; struct usb_device *usbdev; int endpoint; spinlock_t lock; wait_queue_head_t wait; struct usb_mididev *cables[16]; // cables open for read int readers; // number of cables open for read struct urb *urb; unsigned char *recvBuf; int recvBufSize; int urbSubmitted; //FIXME: == readers > 0 }; /* usb_mididev: corresponds to a logical device */ struct usb_mididev { struct list_head list; struct usb_midi_state *midi; int dev_midi; mode_t open_mode; struct { struct midi_in_endpoint *ep; int cableId; // as we are pushing data from usb_bulk_read to usb_midi_read, // we need a larger, cyclic buffer here. unsigned char buf[MIDI_IN_BUFSIZ]; int bufRdPtr; int bufWrPtr; int bufRemains; } min; struct { struct midi_out_endpoint *ep; int cableId; unsigned char buf[3]; int bufPtr; int bufRemains; int isInExclusive; unsigned char lastEvent; } mout; int singlebyte; }; /** Map the high nybble of MIDI voice messages to number of Message bytes. * High nyble ranges from 0x8 to 0xe */ static int remains_80e0[] = { 3, /** 0x8X Note Off **/ 3, /** 0x9X Note On **/ 3, /** 0xAX Poly-key pressure **/ 3, /** 0xBX Control Change **/ 2, /** 0xCX Program Change **/ 2, /** 0xDX Channel pressure **/ 3 /** 0xEX PitchBend Change **/ }; /** Map the messages to a number of Message bytes. * **/ static int remains_f0f6[] = { 0, /** 0xF0 **/ 2, /** 0XF1 **/ 3, /** 0XF2 **/ 2, /** 0XF3 **/ 2, /** 0XF4 (Undefined by MIDI Spec, and subject to change) **/ 2, /** 0XF5 (Undefined by MIDI Spec, and subject to change) **/ 1 /** 0XF6 **/ }; /** Map the messages to a CIN (Code Index Number). * **/ static int cin_f0ff[] = { 4, /** 0xF0 System Exclusive Message Start (special cases may be 6 or 7) */ 2, /** 0xF1 **/ 3, /** 0xF2 **/ 2, /** 0xF3 **/ 2, /** 0xF4 **/ 2, /** 0xF5 **/ 5, /** 0xF6 **/ 5, /** 0xF7 End of System Exclusive Message (May be 6 or 7) **/ 5, /** 0xF8 **/ 5, /** 0xF9 **/ 5, /** 0xFA **/ 5, /** 0xFB **/ 5, /** 0xFC **/ 5, /** 0xFD **/ 5, /** 0xFE **/ 5 /** 0xFF **/ }; /** Map MIDIStreaming Event packet Code Index Number (low nybble of byte 0) * to the number of bytes of valid MIDI data. * * CIN of 0 and 1 are NOT USED in MIDIStreaming 1.0. * **/ static int cin_to_len[] = { 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 }; /* ------------------------------------------------------------------------- */ static struct list_head mididevs = LIST_HEAD_INIT(mididevs); static DECLARE_MUTEX(open_sem); static DECLARE_WAIT_QUEUE_HEAD(open_wait); /* ------------------------------------------------------------------------- */ static void usb_write_callback(struct urb *urb) { struct midi_out_endpoint *ep = (struct midi_out_endpoint *)urb->context; if ( waitqueue_active( &ep->wait ) ) wake_up_interruptible( &ep->wait ); } static int usb_write( struct midi_out_endpoint *ep, unsigned char *buf, int len ) { struct usb_device *d; int pipe; int ret = 0; int status; int maxretry = 50; DECLARE_WAITQUEUE(wait,current); init_waitqueue_head(&ep->wait); d = ep->usbdev; pipe = usb_sndbulkpipe(d, ep->endpoint); FILL_BULK_URB( ep->urb, d, pipe, (unsigned char*)buf, len, (usb_complete_t)usb_write_callback, ep ); status = usb_submit_urb(ep->urb); if (status) { printk(KERN_ERR "usbmidi: Cannot submit urb (%d)\n",status); ret = -EFAULT; } add_wait_queue( &ep->wait, &wait ); set_current_state( TASK_INTERRUPTIBLE ); while( ep->urb->status == -EINPROGRESS ) { if ( maxretry-- < 0 ) { printk(KERN_ERR "usbmidi: usb_bulk_msg timed out\n"); ret = -ETIME; break; } interruptible_sleep_on_timeout( &ep->wait, 10 ); } set_current_state( TASK_RUNNING ); remove_wait_queue( &ep->wait, &wait ); return ret; } /** Copy data from URB to In endpoint buf. * Discard if CIN == 0 or CIN = 1. * * **/ static void usb_bulk_read(struct urb *urb) { struct midi_in_endpoint *ep = (struct midi_in_endpoint *)(urb->context); unsigned char *data = urb->transfer_buffer; int i, j, wake; unsigned long int flags; if ( !ep->urbSubmitted ) { return; } if ( (urb->status == 0) && (urb->actual_length > 0) ) { wake = 0; spin_lock_irqsave( &ep->lock, flags ); for(j = 0; j < urb->actual_length; j += 4) { int cin = (data[j]>>0)&0xf; int cab = (data[j]>>4)&0xf; struct usb_mididev *cable = ep->cables[cab]; if ( cable ) { int len = cin_to_len[cin]; /** length of MIDI data **/ for (i = 0; i < len; i++) { cable->min.buf[cable->min.bufWrPtr] = data[1+i+j]; cable->min.bufWrPtr = (cable->min.bufWrPtr+1)%MIDI_IN_BUFSIZ; if (cable->min.bufRemains < MIDI_IN_BUFSIZ) cable->min.bufRemains += 1; else /** need to drop data **/ cable->min.bufRdPtr += (cable->min.bufRdPtr+1)%MIDI_IN_BUFSIZ; wake = 1; } } } spin_unlock_irqrestore( &ep->lock, flags ); if ( wake ) { wake_up( &ep->wait ); } } /* urb->dev must be reinitialized on 2.4.x kernels */ urb->dev = ep->usbdev; urb->actual_length = 0; usb_submit_urb(urb); } /* ------------------------------------------------------------------------- */ /* This routine must be called with spin_lock */ /** Wrapper around usb_write(). * This routine must be called with spin_lock held on ep. * Called by midiWrite(), putOneMidiEvent(), and usb_midi_write(); **/ static int flush_midi_buffer( struct midi_out_endpoint *ep ) { int ret=0; if ( ep->bufWrPtr > 0 ) { ret = usb_write( ep, ep->buf, ep->bufWrPtr ); ep->bufWrPtr = 0; } return ret; } /* ------------------------------------------------------------------------- */ /** Given a MIDI Event, determine size of data to be attached to * USB-MIDI packet. * Returns 1, 2 or 3. * Called by midiWrite(); * Uses remains_80e0 and remains_f0f6; **/ static int get_remains(int event) { int ret; if ( event < 0x80 ) { ret = 1; } else if ( event < 0xf0 ) { ret = remains_80e0[((event-0x80)>>4)&0x0f]; } else if ( event < 0xf7 ) { ret = remains_f0f6[event-0xf0]; } else { ret = 1; } return ret; } /** Given the output MIDI data in the output buffer, computes a reasonable * CIN. * Called by putOneMidiEvent(). **/ static int get_CIN( struct usb_mididev *m ) { int cin; if ( m->mout.buf[0] == 0xf7 ) { cin = 5; } else if ( m->mout.buf[1] == 0xf7 ) { cin = 6; } else if ( m->mout.buf[2] == 0xf7 ) { cin = 7; } else { if ( m->mout.isInExclusive == 1 ) { cin = 4; } else if ( m->mout.buf[0] < 0x80 ) { /** One byte that we know nothing about. **/ cin = 0xF; } else if ( m->mout.buf[0] < 0xf0 ) { /** MIDI Voice messages 0x8X to 0xEX map to cin 0x8 to 0xE. **/ cin = (m->mout.buf[0]>>4)&0x0f; } else { /** Special lookup table exists for real-time events. **/ cin = cin_f0ff[m->mout.buf[0]-0xf0]; } } return cin; } /* ------------------------------------------------------------------------- */ /** Move data to USB endpoint buffer. * **/ static int put_one_midi_event(struct usb_mididev *m) { int cin; unsigned long flags; struct midi_out_endpoint *ep = m->mout.ep; int ret=0; cin = get_CIN( m ); if ( cin > 0x0f || cin < 0 ) { return -EINVAL; } spin_lock_irqsave( &ep->lock, flags ); ep->buf[ep->bufWrPtr++] = (m->mout.cableId<<4) | cin; ep->buf[ep->bufWrPtr++] = m->mout.buf[0]; ep->buf[ep->bufWrPtr++] = m->mout.buf[1]; ep->buf[ep->bufWrPtr++] = m->mout.buf[2]; if ( ep->bufWrPtr >= ep->bufSize ) { ret = flush_midi_buffer( ep ); } spin_unlock_irqrestore( &ep->lock, flags); m->mout.buf[0] = m->mout.buf[1] = m->mout.buf[2] = 0; m->mout.bufPtr = 0; return ret; } /** Write the MIDI message v on the midi device. * Called by usb_midi_write(); * Responsible for packaging a MIDI data stream into USB-MIDI packets. **/ static int midi_write( struct usb_mididev *m, int v ) { unsigned long flags; struct midi_out_endpoint *ep = m->mout.ep; int ret=0; unsigned char c = (unsigned char)v; unsigned char sysrt_buf[4]; if ( m->singlebyte != 0 ) { /** Simple code to handle the single-byte USB-MIDI protocol. */ spin_lock_irqsave( &ep->lock, flags ); if ( ep->bufWrPtr+4 > ep->bufSize ) { ret = flush_midi_buffer( ep ); if ( !ret ) { spin_unlock_irqrestore( &ep->lock, flags ); return ret; } } ep->buf[ep->bufWrPtr++] = (m->mout.cableId<<4) | 0x0f; /* single byte */ ep->buf[ep->bufWrPtr++] = c; ep->buf[ep->bufWrPtr++] = 0; ep->buf[ep->bufWrPtr++] = 0; if ( ep->bufWrPtr >= ep->bufSize ) { ret = flush_midi_buffer( ep ); } spin_unlock_irqrestore( &ep->lock, flags ); return ret; } /** Normal USB-MIDI protocol begins here. */ if ( c > 0xf7 ) { /* system: Realtime messages */ /** Realtime messages are written IMMEDIATELY. */ sysrt_buf[0] = (m->mout.cableId<<4) | 0x0f; sysrt_buf[1] = c; sysrt_buf[2] = 0; sysrt_buf[3] = 0; spin_lock_irqsave( &ep->lock, flags ); ret = usb_write( ep, sysrt_buf, 4 ); spin_unlock_irqrestore( &ep->lock, flags ); /* m->mout.lastEvent = 0; */ return ret; } if ( c >= 0x80 ) { if ( c < 0xf0 ) { m->mout.lastEvent = c; m->mout.isInExclusive = 0; m->mout.bufRemains = get_remains(c); } else if ( c == 0xf0 ) { /* m->mout.lastEvent = 0; */ m->mout.isInExclusive = 1; m->mout.bufRemains = get_remains(c); } else if ( c == 0xf7 && m->mout.isInExclusive == 1 ) { /* m->mout.lastEvent = 0; */ m->mout.isInExclusive = 0; m->mout.bufRemains = 1; } else if ( c > 0xf0 ) { /* m->mout.lastEvent = 0; */ m->mout.isInExclusive = 0; m->mout.bufRemains = get_remains(c); } } else if ( m->mout.bufRemains == 0 && m->mout.isInExclusive == 0 ) { if ( m->mout.lastEvent == 0 ) { return 0; /* discard, waiting for the first event */ } /** track status **/ m->mout.buf[0] = m->mout.lastEvent; m->mout.bufPtr = 1; m->mout.bufRemains = get_remains(m->mout.lastEvent)-1; } m->mout.buf[m->mout.bufPtr++] = c; m->mout.bufRemains--; if ( m->mout.bufRemains == 0 || m->mout.bufPtr >= 3) { ret = put_one_midi_event(m); } return ret; } /* ------------------------------------------------------------------------- */ /** Basic operation on /dev/midiXX as registered through struct file_operations. * * Basic contract: Used to change the current read/write position in a file. * On success, the non-negative position is reported. * On failure, the negative of an error code is reported. * * Because a MIDIStream is not a file, all seek operations are doomed to fail. * **/ static loff_t usb_midi_llseek(struct file *file, loff_t offset, int origin) { /** Tell user you cannot seek on a PIPE-like device. **/ return -ESPIPE; } /** Basic operation on /dev/midiXX as registered through struct file_operations. * * Basic contract: Block until count bytes have been read or an error occurs. * **/ static ssize_t usb_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos) { struct usb_mididev *m = (struct usb_mididev *)file->private_data; struct midi_in_endpoint *ep = m->min.ep; ssize_t ret; DECLARE_WAITQUEUE(wait, current); if ( ppos != &file->f_pos ) { return -ESPIPE; } if ( !access_ok(VERIFY_READ, buffer, count) ) { return -EFAULT; } if ( count == 0 ) { return 0; } add_wait_queue( &ep->wait, &wait ); ret = 0; while( count > 0 ) { int cnt; int d = (int)count; cnt = m->min.bufRemains; if ( cnt > d ) { cnt = d; } if ( cnt <= 0 ) { if ( file->f_flags & O_NONBLOCK ) { if (!ret) ret = -EAGAIN; break; } __set_current_state(TASK_INTERRUPTIBLE); schedule(); if (signal_pending(current)) { if(!ret) ret=-ERESTARTSYS; break; } continue; } { int i; unsigned long flags; /* used to synchronize access to the endpoint */ spin_lock_irqsave( &ep->lock, flags ); for (i = 0; i < cnt; i++) { if ( copy_to_user( buffer+i, m->min.buf+m->min.bufRdPtr, 1 ) ) { if ( !ret ) ret = -EFAULT; break; } m->min.bufRdPtr = (m->min.bufRdPtr+1)%MIDI_IN_BUFSIZ; m->min.bufRemains -= 1; } spin_unlock_irqrestore( &ep->lock, flags ); } count-=cnt; buffer+=cnt; ret+=cnt; break; } remove_wait_queue( &ep->wait, &wait ); set_current_state(TASK_RUNNING); return ret; } /** Basic operation on /dev/midiXX as registered through struct file_operations. * * Basic Contract: Take MIDI data byte-by-byte and pass it to * writeMidi() which packages MIDI data into USB-MIDI stream. * Then flushMidiData() is called to ensure all bytes have been written * in a timely fashion. * **/ static ssize_t usb_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos) { struct usb_mididev *m = (struct usb_mididev *)file->private_data; ssize_t ret; unsigned long int flags; if ( ppos != &file->f_pos ) { return -ESPIPE; } if ( !access_ok(VERIFY_READ, buffer, count) ) { return -EFAULT; } if ( count == 0 ) { return 0; } ret = 0; while( count > 0 ) { unsigned char c; if (copy_from_user((unsigned char *)&c, buffer, 1)) { if ( ret == 0 ) ret = -EFAULT; break; } if( midi_write(m, (int)c) ) { if ( ret == 0 ) ret = -EFAULT; break; } count--; buffer++; ret++; } spin_lock_irqsave( &m->mout.ep->lock, flags ); if ( flush_midi_buffer(m->mout.ep) < 0 ) { ret = -EFAULT; } spin_unlock_irqrestore( &m->mout.ep->lock, flags ); return ret; } /** Basic operation on /dev/midiXX as registered through struct file_operations. * * Basic contract: Wait (spin) until ready to read or write on the file. * **/ static unsigned int usb_midi_poll(struct file *file, struct poll_table_struct *wait) { struct usb_mididev *m = (struct usb_mididev *)file->private_data; struct midi_in_endpoint *iep = m->min.ep; struct midi_out_endpoint *oep = m->mout.ep; unsigned long flags; unsigned int mask = 0; if ( file->f_mode & FMODE_READ ) { poll_wait( file, &iep->wait, wait ); spin_lock_irqsave( &iep->lock, flags ); if ( m->min.bufRemains > 0 ) mask |= POLLIN | POLLRDNORM; spin_unlock_irqrestore( &iep->lock, flags ); } if ( file->f_mode & FMODE_WRITE ) { poll_wait( file, &oep->wait, wait ); spin_lock_irqsave( &oep->lock, flags ); if ( oep->bufWrPtr < oep->bufSize ) mask |= POLLOUT | POLLWRNORM; spin_unlock_irqrestore( &oep->lock, flags ); } return mask; } /** Basic operation on /dev/midiXX as registered through struct file_operations. * * Basic contract: This is always the first operation performed on the * device node. If no method is defined, the open succeeds without any * notification given to the module. * **/ static int usb_midi_open(struct inode *inode, struct file *file) { int minor = MINOR(inode->i_rdev); DECLARE_WAITQUEUE(wait, current); struct list_head *devs, *mdevs; struct usb_midi_state *s; struct usb_mididev *m; int flags; int succeed = 0; #if 0 printk(KERN_INFO "usb-midi: Open minor= %d.\n", minor); #endif for(;;) { down(&open_sem); for (devs = mididevs.next; devs != &mididevs; devs = devs->next) { s = list_entry(devs, struct usb_midi_state, mididev); for (mdevs = s->midiDevList.next; mdevs != &s->midiDevList; mdevs = mdevs->next) { m = list_entry(mdevs, struct usb_mididev, list); if ( !((m->dev_midi ^ minor) & ~0xf) ) goto device_found; } } up(&open_sem); return -ENODEV; device_found: if ( !s->usbdev ) { up(&open_sem); return -EIO; } if ( !(m->open_mode & file->f_mode) ) { break; } if ( file->f_flags & O_NONBLOCK ) { up(&open_sem); return -EBUSY; } __set_current_state(TASK_INTERRUPTIBLE); add_wait_queue( &open_wait, &wait ); up(&open_sem); schedule(); __set_current_state(TASK_RUNNING); remove_wait_queue( &open_wait, &wait ); if ( signal_pending(current) ) { return -ERESTARTSYS; } } file->private_data = m; spin_lock_irqsave( &s->lock, flags ); if ( !(m->open_mode & (FMODE_READ | FMODE_WRITE)) ) { //FIXME: intented semantics unclear here m->min.bufRdPtr = 0; m->min.bufWrPtr = 0; m->min.bufRemains = 0; spin_lock_init(&m->min.ep->lock); m->mout.bufPtr = 0; m->mout.bufRemains = 0; m->mout.isInExclusive = 0; m->mout.lastEvent = 0; spin_lock_init(&m->mout.ep->lock); } if ( (file->f_mode & FMODE_READ) && m->min.ep != NULL ) { unsigned long int flagsep; spin_lock_irqsave( &m->min.ep->lock, flagsep ); m->min.ep->cables[m->min.cableId] = m; m->min.ep->readers += 1; m->min.bufRdPtr = 0; m->min.bufWrPtr = 0; m->min.bufRemains = 0; spin_unlock_irqrestore( &m->min.ep->lock, flagsep ); if ( !(m->min.ep->urbSubmitted)) { /* urb->dev must be reinitialized on 2.4.x kernels */ m->min.ep->urb->dev = m->min.ep->usbdev; if ( usb_submit_urb(m->min.ep->urb) ) { printk(KERN_ERR "usbmidi: Cannot submit urb for MIDI-IN\n"); } m->min.ep->urbSubmitted = 1; } m->open_mode |= FMODE_READ; succeed = 1; } if ( (file->f_mode & FMODE_WRITE) && m->mout.ep != NULL ) { m->mout.bufPtr = 0; m->mout.bufRemains = 0; m->mout.isInExclusive = 0; m->mout.lastEvent = 0; m->open_mode |= FMODE_WRITE; succeed = 1; } spin_unlock_irqrestore( &s->lock, flags ); s->count++; up(&open_sem); /** Changed to prevent extra increments to USE_COUNT. **/ if (!succeed) { return -EBUSY; } #if 0 printk(KERN_INFO "usb-midi: Open Succeeded. minor= %d.\n", minor); #endif /** Side-effect: module cannot be removed until USE_COUNT is 0. **/ #ifndef MOD_INC_EACH_PROBE MOD_INC_USE_COUNT; #endif return 0; /** Success. **/ } /** Basic operation on /dev/midiXX as registered through struct file_operations. * * Basic contract: Close an opened file and deallocate anything we allocated. * Like open(), this can be missing. If open set file->private_data, * release() must clear it. * **/ static int usb_midi_release(struct inode *inode, struct file *file) { struct usb_mididev *m = (struct usb_mididev *)file->private_data; struct usb_midi_state *s = (struct usb_midi_state *)m->midi; #if 0 printk(KERN_INFO "usb-midi: Close.\n"); #endif down(&open_sem); if ( m->open_mode & FMODE_WRITE ) { m->open_mode &= ~FMODE_WRITE; usb_unlink_urb( m->mout.ep->urb ); } if ( m->open_mode & FMODE_READ ) { unsigned long int flagsep; spin_lock_irqsave( &m->min.ep->lock, flagsep ); m->min.ep->cables[m->min.cableId] = 0; // discard cable m->min.ep->readers -= 1; m->open_mode &= ~FMODE_READ; if ( m->min.ep->readers == 0 && m->min.ep->urbSubmitted ) { m->min.ep->urbSubmitted = 0; usb_unlink_urb(m->min.ep->urb); } spin_unlock_irqrestore( &m->min.ep->lock, flagsep ); } s->count--; up(&open_sem); wake_up(&open_wait); file->private_data = 0; /** Sideeffect: Module cannot be removed until usecount is 0. */ #ifndef MOD_INC_EACH_PROBE MOD_DEC_USE_COUNT; #endif return 0; } static struct file_operations usb_midi_fops = { llseek: usb_midi_llseek, read: usb_midi_read, write: usb_midi_write, poll: usb_midi_poll, open: usb_midi_open, release: usb_midi_release, }; /* ------------------------------------------------------------------------- */ /** Returns filled midi_in_endpoint structure or null on failure. * * Parameters: * d - a usb_device * endPoint - An usb endpoint in the range 0 to 15. * Called by allocUsbMidiDev(); * **/ static struct midi_in_endpoint *alloc_midi_in_endpoint( struct usb_device *d, int endPoint ) { struct midi_in_endpoint *ep; int bufSize; int pipe; endPoint &= 0x0f; /* Silently force endPoint to lie in range 0 to 15. */ pipe = usb_rcvbulkpipe( d, endPoint ); bufSize = usb_maxpacket( d, pipe, usb_pipein(pipe) ); /* usb_pipein() = ! usb_pipeout() = true for an in Endpoint */ ep = (struct midi_in_endpoint *)kmalloc(sizeof(struct midi_in_endpoint), GFP_KERNEL); if ( !ep ) { printk(KERN_ERR "usbmidi: no memory for midi in-endpoint\n"); return NULL; } memset( ep, 0, sizeof(struct midi_in_endpoint) ); // this sets cables[] and readers to 0, too. // for (i=0; i<16; i++) ep->cables[i] = 0; // discard cable // ep->readers = 0; ep->endpoint = endPoint; ep->recvBuf = (unsigned char *)kmalloc(sizeof(unsigned char)*(bufSize), GFP_KERNEL); if ( !ep->recvBuf ) { printk(KERN_ERR "usbmidi: no memory for midi in-endpoint buffer\n"); kfree(ep); return NULL; } ep->urb = usb_alloc_urb(0); /* no ISO */ if ( !ep->urb ) { printk(KERN_ERR "usbmidi: no memory for midi in-endpoint urb\n"); kfree(ep->recvBuf); kfree(ep); return NULL; } FILL_BULK_URB( ep->urb, d, usb_rcvbulkpipe(d, endPoint), (unsigned char *)ep->recvBuf, bufSize, (usb_complete_t)usb_bulk_read, ep ); /* ep->bufRdPtr = 0; */ /* ep->bufWrPtr = 0; */ /* ep->bufRemains = 0; */ /* ep->urbSubmitted = 0; */ ep->recvBufSize = bufSize; init_waitqueue_head(&ep->wait); return ep; } static int remove_midi_in_endpoint( struct midi_in_endpoint *min ) { usb_unlink_urb( min->urb ); usb_free_urb( min->urb ); kfree( min->recvBuf ); kfree( min ); return 0; } /** Returns filled midi_out_endpoint structure or null on failure. * * Parameters: * d - a usb_device * endPoint - An usb endpoint in the range 0 to 15. * Called by allocUsbMidiDev(); * **/ static struct midi_out_endpoint *alloc_midi_out_endpoint( struct usb_device *d, int endPoint ) { struct midi_out_endpoint *ep = NULL; int pipe; int bufSize; endPoint &= 0x0f; pipe = usb_sndbulkpipe( d, endPoint ); bufSize = usb_maxpacket( d, pipe, usb_pipeout(pipe) ); ep = (struct midi_out_endpoint *)kmalloc(sizeof(struct midi_out_endpoint), GFP_KERNEL); if ( !ep ) { printk(KERN_ERR "usbmidi: no memory for midi out-endpoint\n"); return NULL; } memset( ep, 0, sizeof(struct midi_out_endpoint) ); ep->endpoint = endPoint; ep->buf = (unsigned char *)kmalloc(sizeof(unsigned char)*bufSize, GFP_KERNEL); if ( !ep->buf ) { printk(KERN_ERR "usbmidi: no memory for midi out-endpoint buffer\n"); kfree(ep); return NULL; } ep->urb = usb_alloc_urb(0); /* no ISO */ if ( !ep->urb ) { printk(KERN_ERR "usbmidi: no memory for midi out-endpoint urb\n"); kfree(ep->buf); kfree(ep); return NULL; } ep->bufSize = bufSize; /* ep->bufWrPtr = 0; */ init_waitqueue_head(&ep->wait); return ep; } static int remove_midi_out_endpoint( struct midi_out_endpoint *mout ) { usb_unlink_urb( mout->urb ); usb_free_urb( mout->urb ); kfree( mout->buf ); kfree( mout ); return 0; } /** Returns a filled usb_mididev structure, registered as a Linux MIDI device. * * Returns null if memory is not available or the device cannot be registered. * Called by allocUsbMidiDev(); * **/ static struct usb_mididev *allocMidiDev( struct usb_midi_state *s, struct midi_in_endpoint *min, struct midi_out_endpoint *mout, int inCableId, int outCableId ) { struct usb_mididev *m; m = (struct usb_mididev *)kmalloc(sizeof(struct usb_mididev), GFP_KERNEL); if (!m) { printk(KERN_ERR "usbmidi: no memory for midi device\n"); return NULL; } memset(m, 0, sizeof(struct usb_mididev)); if ((m->dev_midi = register_sound_midi(&usb_midi_fops, -1)) < 0) { printk(KERN_ERR "usbmidi: cannot register midi device\n"); kfree(m); return NULL; } m->midi = s; /* m->open_mode = 0; */ if ( min ) { m->min.ep = min; m->min.ep->usbdev = s->usbdev; m->min.cableId = inCableId; } /* m->min.bufPtr = 0; */ /* m->min.bufRemains = 0; */ if ( mout ) { m->mout.ep = mout; m->mout.ep->usbdev = s->usbdev; m->mout.cableId = outCableId; } /* m->mout.bufPtr = 0; */ /* m->mout.bufRemains = 0; */ /* m->mout.isInExclusive = 0; */ /* m->mout.lastEvent = 0; */ m->singlebyte = singlebyte; return m; } static void release_midi_device( struct usb_midi_state *s ) { struct usb_mididev *m; struct midi_in_endpoint *min; struct midi_out_endpoint *mout; if ( s->count > 0 ) { up(&open_sem); return; } up( &open_sem ); wake_up( &open_wait ); while(!list_empty(&s->inEndpointList)) { min = list_entry(s->inEndpointList.next, struct midi_in_endpoint, list); list_del(&min->list); remove_midi_in_endpoint(min); } while(!list_empty(&s->outEndpointList)) { mout = list_entry(s->outEndpointList.next, struct midi_out_endpoint, list); list_del(&mout->list); remove_midi_out_endpoint(mout); } while(!list_empty(&s->midiDevList)) { m = list_entry(s->midiDevList.next, struct usb_mididev, list); list_del(&m->list); kfree(m); } kfree(s); return; } /* ------------------------------------------------------------------------- */ /** Utility routine to find a descriptor in a dump of many descriptors. * Returns start of descriptor or NULL if not found. * descStart pointer to list of interfaces. * descLength length (in bytes) of dump * after (ignored if NULL) this routine returns only descriptors after "after" * dtype (mandatory) The descriptor type. * iface (ignored if -1) returns descriptor at/following given interface * altSetting (ignored if -1) returns descriptor at/following given altSetting * * * Called by parseDescriptor(), find_csinterface_descriptor(); * */ static void *find_descriptor( void *descStart, unsigned int descLength, void *after, unsigned char dtype, int iface, int altSetting ) { unsigned char *p, *end, *next; int interfaceNumber = -1, altSet = -1; p = descStart; end = p + descLength; for( ; p < end; ) { if ( p[0] < 2 ) return NULL; next = p + p[0]; if ( next > end ) return NULL; if ( p[1] == USB_DT_INTERFACE ) { if ( p[0] < USB_DT_INTERFACE_SIZE ) return NULL; interfaceNumber = p[2]; altSet = p[3]; } if ( p[1] == dtype && ( !after || ( p > (unsigned char *)after) ) && ( ( iface == -1) || (iface == interfaceNumber) ) && ( (altSetting == -1) || (altSetting == altSet) )) { return p; } p = next; } return NULL; } /** Utility to find a class-specfic interface descriptor. * dsubtype is a descriptor subtype * Called by parseDescriptor(); **/ static void *find_csinterface_descriptor(void *descStart, unsigned int descLength, void *after, u8 dsubtype, int iface, int altSetting) { unsigned char *p; p = find_descriptor( descStart, descLength, after, USB_DT_CS_INTERFACE, iface, altSetting ); while ( p ) { if ( p[0] >= 3 && p[2] == dsubtype ) return p; p = find_descriptor( descStart, descLength, p, USB_DT_CS_INTERFACE, iface, altSetting ); } return NULL; } /** The magic of making a new usb_midi_device from config happens here. * * The caller is responsible for free-ing this return value (if not NULL). * **/ static struct usb_midi_device *parse_descriptor( struct usb_device *d, unsigned char *buffer, int bufSize, unsigned int ifnum , unsigned int altSetting, int quirks) { struct usb_midi_device *u; unsigned char *p1; unsigned char *p2; unsigned char *next; int iep, oep; int length; unsigned long longBits; int pins, nbytes, offset, shift, jack; #ifdef HAVE_JACK_STRINGS /** Jacks can have associated names. **/ unsigned char jack2string[256]; #endif u = 0; /* find audiocontrol interface */ p1 = find_csinterface_descriptor( buffer, bufSize, NULL, MS_HEADER, ifnum, altSetting); if ( !p1 ) { goto error_end; } if ( p1[0] < MS_HEADER_LENGTH ) { goto error_end; } /* Assume success. Since the device corresponds to USB-MIDI spec, we assume that the rest of the USB 2.0 spec is obeyed. */ u = (struct usb_midi_device *)kmalloc( sizeof(struct usb_midi_device), GFP_KERNEL ); if ( !u ) { return NULL; } u->deviceName = 0; u->idVendor = d->descriptor.idVendor; u->idProduct = d->descriptor.idProduct; u->interface = ifnum; u->altSetting = altSetting; u->in[0].endpoint = -1; u->in[0].cableId = -1; u->out[0].endpoint = -1; u->out[0].cableId = -1; printk(KERN_INFO "usb-midi: Found MIDIStreaming device corresponding to Release %d.%02d of spec.\n", (p1[4] >> 4) * 10 + (p1[4] & 0x0f ), (p1[3] >> 4) * 10 + (p1[3] & 0x0f ) ); length = p1[5] | (p1[6] << 8); #ifdef HAVE_JACK_STRINGS memset(jack2string, 0, sizeof(unsigned char) * 256); #endif length -= p1[0]; for (p2 = p1 + p1[0]; length > 0; p2 = next) { next = p2 + p2[0]; length -= p2[0]; if (p2[0] < 2 ) break; if (p2[1] != USB_DT_CS_INTERFACE) break; if (p2[2] == MIDI_IN_JACK && p2[0] >= 6 ) { jack = p2[4]; #ifdef HAVE_JACK_STRINGS jack2string[jack] = p2[5]; #endif printk(KERN_INFO "usb-midi: Found IN Jack 0x%02x %s\n", jack, (p2[3] == EMBEDDED_JACK)?"EMBEDDED":"EXTERNAL" ); } else if ( p2[2] == MIDI_OUT_JACK && p2[0] >= 6) { pins = p2[5]; if ( p2[0] < (6 + 2 * pins) ) continue; jack = p2[4]; #ifdef HAVE_JACK_STRINGS jack2string[jack] = p2[5 + 2 * pins]; #endif printk(KERN_INFO "usb-midi: Found OUT Jack 0x%02x %s, %d pins\n", jack, (p2[3] == EMBEDDED_JACK)?"EMBEDDED":"EXTERNAL", pins ); } else if ( p2[2] == ELEMENT_DESCRIPTOR && p2[0] >= 10) { pins = p2[4]; if ( p2[0] < (9 + 2 * pins ) ) continue; nbytes = p2[8 + 2 * pins ]; if ( p2[0] < (10 + 2 * pins + nbytes) ) continue; longBits = 0L; for ( offset = 0, shift = 0; offset < nbytes && offset < 8; offset ++, shift += 8) { longBits |= ((long)(p2[9 + 2 * pins + offset])) << shift; } jack = p2[3]; #ifdef HAVE_JACK_STRINGS jack2string[jack] = p2[9 + 2 * pins + nbytes]; #endif printk(KERN_INFO "usb-midi: Found ELEMENT 0x%02x, %d/%d pins in/out, bits: 0x%016lx\n", jack, pins, (int)(p2[5 + 2 * pins]), (long)longBits ); } else { } } iep=0; oep=0; if (quirks==0) { /* MIDISTREAM */ p2 = 0; for (p1 = find_descriptor(buffer, bufSize, NULL, USB_DT_ENDPOINT, ifnum, altSetting ); p1; p1 = next ) { next = find_descriptor(buffer, bufSize, p1, USB_DT_ENDPOINT, ifnum, altSetting ); p2 = find_descriptor(buffer, bufSize, p1, USB_DT_CS_ENDPOINT, ifnum, altSetting ); if ( p2 && next && ( p2 > next ) ) p2 = 0; if ( p1[0] < 9 || !p2 || p2[0] < 4 ) continue; if ( (p1[2] & 0x80) == 0x80 ) { if ( iep < 15 ) { pins = p2[3]; /* not pins -- actually "cables" */ if ( pins > 16 ) pins = 16; u->in[iep].endpoint = p1[2]; u->in[iep].cableId = ( 1 << pins ) - 1; if ( u->in[iep].cableId ) iep ++; if ( iep < 15 ) { u->in[iep].endpoint = -1; u->in[iep].cableId = -1; } } } else { if ( oep < 15 ) { pins = p2[3]; /* not pins -- actually "cables" */ if ( pins > 16 ) pins = 16; u->out[oep].endpoint = p1[2]; u->out[oep].cableId = ( 1 << pins ) - 1; if ( u->out[oep].cableId ) oep ++; if ( oep < 15 ) { u->out[oep].endpoint = -1; u->out[oep].cableId = -1; } } } } } else if (quirks==1) { /* YAMAHA quirks */ for (p1 = find_descriptor(buffer, bufSize, NULL, USB_DT_ENDPOINT, ifnum, altSetting ); p1; p1 = next ) { next = find_descriptor(buffer, bufSize, p1, USB_DT_ENDPOINT, ifnum, altSetting ); if ( p1[0] < 7 ) continue; if ( (p1[2] & 0x80) == 0x80 ) { if ( iep < 15 ) { pins = iep+1; if ( pins > 16 ) pins = 16; u->in[iep].endpoint = p1[2]; u->in[iep].cableId = ( 1 << pins ) - 1; if ( u->in[iep].cableId ) iep ++; if ( iep < 15 ) { u->in[iep].endpoint = -1; u->in[iep].cableId = -1; } } } else { if ( oep < 15 ) { pins = oep+1; if ( pins > 16 ) pins = 16; u->out[oep].endpoint = p1[2]; u->out[oep].cableId = ( 1 << pins ) - 1; if ( u->out[oep].cableId ) oep ++; if ( oep < 15 ) { u->out[oep].endpoint = -1; u->out[oep].cableId = -1; } } } } } if ( !iep && ! oep ) { goto error_end; } return u; error_end: if ( u ) kfree(u); return NULL; } /* ------------------------------------------------------------------------- */ /** Returns number between 0 and 16. * **/ static int on_bits( unsigned short v ) { int i; int ret=0; for ( i=0 ; i<16 ; i++ ) { if ( v & (1<<i) ) ret++; } return ret; } /** USB-device will be interrogated for altSetting. * * Returns negative on error. * Called by allocUsbMidiDev(); * **/ static int get_alt_setting( struct usb_device *d, int ifnum ) { int alts, alt=0; struct usb_interface_descriptor *interface; struct usb_endpoint_descriptor *ep; int epin, epout; int i; alts = d->actconfig->interface[ifnum].num_altsetting; for ( alt=0 ; alt<alts ; alt++ ) { interface = &d->actconfig->interface[ifnum].altsetting[alt]; epin = -1; epout = -1; for ( i=0 ; i<interface->bNumEndpoints ; i++ ) { ep = &interface->endpoint[i]; if ( (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ) { continue; } if ( (ep->bEndpointAddress & USB_DIR_IN) && epin < 0 ) { epin = i; } else if ( epout < 0 ) { epout = i; } if ( epin >= 0 && epout >= 0 ) { return alt; } } } return -ENODEV; } /* ------------------------------------------------------------------------- */ /** Returns 0 if successful in allocating and registering internal structures. * Returns negative on failure. * Calls allocMidiDev which additionally registers /dev/midiXX devices. * Writes messages on success to indicate which /dev/midiXX is which physical * endpoint. * **/ static int alloc_usb_midi_device( struct usb_device *d, struct usb_midi_state *s, struct usb_midi_device *u ) { struct usb_mididev **mdevs=NULL; struct midi_in_endpoint *mins[15], *min; struct midi_out_endpoint *mouts[15], *mout; int inDevs=0, outDevs=0; int inEndpoints=0, outEndpoints=0; int inEndpoint, outEndpoint; int inCableId, outCableId; int i; int devices = 0; int alt = 0; /* Obtain altSetting or die.. */ alt = u->altSetting; if ( alt < 0 ) { alt = get_alt_setting( d, u->interface ); } if ( alt < 0 ) { return -ENXIO; } /* Configure interface */ if ( usb_set_interface( d, u->interface, alt ) < 0 ) { return -ENXIO; } for ( i = 0 ; i < 15 ; i++ ) { mins[i] = NULL; mouts[i] = NULL; } /* Begin Allocation */ while( inEndpoints < 15 && inDevs < maxdevices && u->in[inEndpoints].cableId >= 0 ) { inDevs += on_bits((unsigned short)u->in[inEndpoints].cableId); mins[inEndpoints] = alloc_midi_in_endpoint( d, u->in[inEndpoints].endpoint ); if ( mins[inEndpoints] == NULL ) { goto error_end; } inEndpoints++; } while( outEndpoints < 15 && outDevs < maxdevices && u->out[outEndpoints].cableId >= 0 ) { outDevs += on_bits((unsigned short)u->out[outEndpoints].cableId); mouts[outEndpoints] = alloc_midi_out_endpoint( d, u->out[outEndpoints].endpoint ); if ( mouts[outEndpoints] == NULL ) { goto error_end; } outEndpoints++; } devices = inDevs > outDevs ? inDevs : outDevs; devices = maxdevices > devices ? devices : maxdevices; /* obtain space for device name (iProduct) if not known. */ if ( ! u->deviceName ) { mdevs = (struct usb_mididev **) kmalloc(sizeof(struct usb_mididevs *)*devices + sizeof(char) * 256, GFP_KERNEL); } else { mdevs = (struct usb_mididev **) kmalloc(sizeof(struct usb_mididevs *)*devices, GFP_KERNEL); } if ( !mdevs ) { /* devices = 0; */ /* mdevs = NULL; */ goto error_end; } for ( i=0 ; i<devices ; i++ ) { mdevs[i] = NULL; } /* obtain device name (iProduct) if not known. */ if ( ! u->deviceName ) { u->deviceName = (char *) (mdevs + devices); if ( ! d->have_langid && d->descriptor.iProduct) { alt = usb_get_string(d, 0, 0, u->deviceName, 250); if (alt < 0) { printk(KERN_INFO "error getting string descriptor 0 (error=%d)\n", alt); } else if (u->deviceName[0] < 4) { printk(KERN_INFO "string descriptor 0 too short (length = %d)\n", alt); } else { printk(KERN_INFO "string descriptor 0 found (length = %d)\n", alt); for(; alt >= 4; alt -= 2) { i = u->deviceName[alt-2] | (u->deviceName[alt-1]<< 8); printk(KERN_INFO "usb-midi: langid(%d) 0x%04x\n", (alt-4) >> 1, i); if ( ( ( i ^ ulangid ) & 0xff ) == 0 ) { d->have_langid = 1; d->string_langid = i; printk(KERN_INFO "usb-midi: langid(match) 0x%04x\n", i); if ( i == ulangid ) break; } } } } u->deviceName[0] = (char) 0; if (d->descriptor.iProduct) { printk(KERN_INFO "usb-midi: fetchString(%d)\n", d->descriptor.iProduct); alt = usb_string(d, d->descriptor.iProduct, u->deviceName, 255); if( alt < 0 ) { u->deviceName[0] = (char) 0; } printk(KERN_INFO "usb-midi: fetchString = %d\n", alt); } /* Failsafe */ if ( !u->deviceName[0] ) { if ( d->descriptor.idVendor == USB_VENDOR_ID_ROLAND ) { strcpy(u->deviceName, "Unknown Roland"); } else if ( d->descriptor.idVendor == USB_VENDOR_ID_STEINBERG ) { strcpy(u->deviceName, "Unknown Steinberg"); } else if ( d->descriptor.idVendor == USB_VENDOR_ID_YAMAHA ) { strcpy(u->deviceName, "Unknown Yamaha"); } else { strcpy(u->deviceName, "Unknown"); } } } inEndpoint = 0; inCableId = -1; outEndpoint = 0; outCableId = -1; for ( i=0 ; i<devices ; i++ ) { for ( inCableId ++ ; inEndpoint <15 && mins[inEndpoint] && !(u->in[inEndpoint].cableId & (1<<inCableId)) ; inCableId++ ) { if ( inCableId >= 16 ) { inEndpoint ++; inCableId = 0; } } min = mins[inEndpoint]; for ( outCableId ++ ; outEndpoint <15 && mouts[outEndpoint] && !(u->out[outEndpoint].cableId & (1<<outCableId)) ; outCableId++ ) { if ( outCableId >= 16 ) { outEndpoint ++; outCableId = 0; } } mout = mouts[outEndpoint]; mdevs[i] = allocMidiDev( s, min, mout, inCableId, outCableId ); if ( mdevs[i] == NULL ) { goto error_end; } } /* Success! */ for ( i=0 ; i<devices ; i++ ) { list_add_tail( &mdevs[i]->list, &s->midiDevList ); } for ( i=0 ; i<inEndpoints ; i++ ) { list_add_tail( &mins[i]->list, &s->inEndpointList ); } for ( i=0 ; i<outEndpoints ; i++ ) { list_add_tail( &mouts[i]->list, &s->outEndpointList ); } printk(KERN_INFO "usbmidi: found [ %s ] (0x%04x:0x%04x), attached:\n", u->deviceName, u->idVendor, u->idProduct ); for ( i=0 ; i<devices ; i++ ) { int dm = (mdevs[i]->dev_midi-2)>>4; if ( mdevs[i]->mout.ep != NULL && mdevs[i]->min.ep != NULL ) { printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%2d) out (ep:%02x cid:%2d bufsiz:%2d)\n", dm, mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize, mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize); } else if ( mdevs[i]->min.ep != NULL ) { printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%02d)\n", dm, mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize); } else if ( mdevs[i]->mout.ep != NULL ) { printk(KERN_INFO "usbmidi: /dev/midi%02d: out (ep:%02x cid:%2d bufsiz:%02d)\n", dm, mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize); } } kfree(mdevs); return 0; error_end: if ( mdevs != NULL && devices > 0 ) { for ( i=0 ; i<devices ; i++ ) { if ( mdevs[i] != NULL ) { unregister_sound_midi( mdevs[i]->dev_midi ); kfree(mdevs[i]); } } kfree(mdevs); } for ( i=0 ; i<15 ; i++ ) { if ( mins[i] != NULL ) { remove_midi_in_endpoint( mins[i] ); } if ( mouts[i] != NULL ) { remove_midi_out_endpoint( mouts[i] ); } } return -ENOMEM; } /* ------------------------------------------------------------------------- */ /** Attempt to scan YAMAHA's device descriptor and detect correct values of * them. * Return 0 on succes, negative on failure. * Called by usb_midi_probe(); **/ static int detect_yamaha_device( struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s) { struct usb_config_descriptor *c = d->actconfig; struct usb_interface_descriptor *interface; struct usb_midi_device *u; unsigned char buf[USB_DT_CONFIG_SIZE], *buffer; int bufSize; int i; int alts=-1; int ret; if (d->descriptor.idVendor != USB_VENDOR_ID_YAMAHA) { return -EINVAL; } for ( i=0 ; i < c->interface[ifnum].num_altsetting; i++ ) { interface = c->interface[ifnum].altsetting + i; if ( interface->bInterfaceClass != 255 || interface->bInterfaceSubClass != 0 ) continue; alts = i; } if ( alts == -1 ) { return -EINVAL; } printk(KERN_INFO "usb-midi: Found YAMAHA USB-MIDI device on dev %04x:%04x, iface %d\n", d->descriptor.idVendor, d->descriptor.idProduct, ifnum); for ( i=0 ; i < d->descriptor.bNumConfigurations ; i++ ) { if ( d->config+i == c ) goto configfound; } printk(KERN_INFO "usb-midi: Config not found.\n"); return -EINVAL; configfound: /* this may not be necessary. */ if ( usb_set_configuration( d, c->bConfigurationValue ) < 0 ) { printk(KERN_INFO "usb-midi: Could not set config.\n"); return -EINVAL; } ret = usb_get_descriptor( d, USB_DT_CONFIG, i, buf, USB_DT_CONFIG_SIZE ); if ( ret < 0 ) { printk(KERN_INFO "usb-midi: Could not get config (error=%d).\n", ret); return -EINVAL; } if ( buf[1] != USB_DT_CONFIG || buf[0] < USB_DT_CONFIG_SIZE ) { printk(KERN_INFO "usb-midi: config not as expected.\n"); return -EINVAL; } bufSize = buf[2] | buf[3]<<8; buffer = (unsigned char *)kmalloc(sizeof(unsigned char)*bufSize, GFP_KERNEL); if ( !buffer ) { printk(KERN_INFO "usb-midi: Could not allocate memory.\n"); return -EINVAL; } ret = usb_get_descriptor( d, USB_DT_CONFIG, i, buffer, bufSize ); if ( ret < 0 ) { printk(KERN_INFO "usb-midi: Could not get full config (error=%d).\n", ret); kfree(buffer); return -EINVAL; } u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 1); kfree(buffer); if ( u == NULL ) { return -EINVAL; } ret = alloc_usb_midi_device( d, s, u ); kfree(u); return ret; } /** Scan table of known devices which are only partially compliant with * the MIDIStreaming specification. * Called by usb_midi_probe(); * **/ static int detect_vendor_specific_device( struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s ) { struct usb_midi_device *u; int i; int ret = -ENXIO; for ( i=0; i<VENDOR_SPECIFIC_USB_MIDI_DEVICES ; i++ ) { u=&(usb_midi_devices[i]); if ( d->descriptor.idVendor != u->idVendor || d->descriptor.idProduct != u->idProduct || ifnum != u->interface ) continue; ret = alloc_usb_midi_device( d, s, u ); break; } return ret; } /** Attempt to match any config of an interface to a MIDISTREAMING interface. * Returns 0 on success, negative on failure. * Called by usb_midi_probe(); **/ static int detect_midi_subclass(struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s) { struct usb_config_descriptor *c = d->actconfig; struct usb_interface_descriptor *interface; struct usb_midi_device *u; unsigned char buf[USB_DT_CONFIG_SIZE], *buffer; int bufSize; int i; int alts=-1; int ret; for ( i=0 ; i < c->interface[ifnum].num_altsetting; i++ ) { interface = c->interface[ifnum].altsetting + i; if ( interface->bInterfaceClass != USB_CLASS_AUDIO || interface->bInterfaceSubClass != USB_SUBCLASS_MIDISTREAMING ) continue; alts = i; } if ( alts == -1 ) { return -EINVAL; } printk(KERN_INFO "usb-midi: Found MIDISTREAMING on dev %04x:%04x, iface %d\n", d->descriptor.idVendor, d->descriptor.idProduct, ifnum); for ( i=0 ; i < d->descriptor.bNumConfigurations ; i++ ) { if ( d->config+i == c ) goto configfound; } printk(KERN_INFO "usb-midi: Config not found.\n"); return -EINVAL; configfound: /* this may not be necessary. */ if ( usb_set_configuration( d, c->bConfigurationValue ) < 0 ) { printk(KERN_INFO "usb-midi: Could not set config.\n"); return -EINVAL; } /* From USB Spec v2.0, Section 9.5. If the class or vendor specific descriptors use the same format as standard descriptors (e.g., start with a length byte and followed by a type byte), they must be returned interleaved with standard descriptors in the configuration information returned by a GetDescriptor(Configuration) request. In this case, the class or vendor-specific descriptors must follow a related standard descriptor they modify or extend. */ ret = usb_get_descriptor( d, USB_DT_CONFIG, i, buf, USB_DT_CONFIG_SIZE ); if ( ret < 0 ) { printk(KERN_INFO "usb-midi: Could not get config (error=%d).\n", ret); return -EINVAL; } if ( buf[1] != USB_DT_CONFIG || buf[0] < USB_DT_CONFIG_SIZE ) { printk(KERN_INFO "usb-midi: config not as expected.\n"); return -EINVAL; } bufSize = buf[2] | buf[3]<<8; buffer = (unsigned char *)kmalloc(sizeof(unsigned char)*bufSize, GFP_KERNEL); if ( !buffer ) { printk(KERN_INFO "usb-midi: Could not allocate memory.\n"); return -EINVAL; } ret = usb_get_descriptor( d, USB_DT_CONFIG, i, buffer, bufSize ); if ( ret < 0 ) { printk(KERN_INFO "usb-midi: Could not get full config (error=%d).\n", ret); kfree(buffer); return -EINVAL; } u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 0); kfree(buffer); if ( u == NULL ) { return -EINVAL; } ret = alloc_usb_midi_device( d, s, u ); kfree(u); return ret; } /** When user has requested a specific device, match it exactly. * * Uses uvendor, uproduct, uinterface, ualt, umin, umout and ucable. * Called by usb_midi_probe(); * **/ static int detect_by_hand(struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s) { struct usb_midi_device u; if ( d->descriptor.idVendor != uvendor || d->descriptor.idProduct != uproduct || ifnum != uinterface ) { return -EINVAL; } if ( ualt < 0 ) { ualt = -1; } if ( umin < 0 || umin > 15 ) { umin = 0x01 | USB_DIR_IN; } if ( umout < 0 || umout > 15 ) { umout = 0x01; } if ( ucable < 0 || ucable > 15 ) { ucable = 0; } u.deviceName = 0; /* A flag for alloc_usb_midi_device to get device name from device. */ u.idVendor = uvendor; u.idProduct = uproduct; u.interface = uinterface; u.altSetting = ualt; u.in[0].endpoint = umin; u.in[0].cableId = (1<<ucable); u.out[0].endpoint = umout; u.out[0].cableId = (1<<ucable); return alloc_usb_midi_device( d, s, &u ); } /* ------------------------------------------------------------------------- */ static void *usb_midi_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id) { struct usb_midi_state *s; s = (struct usb_midi_state *)kmalloc(sizeof(struct usb_midi_state), GFP_KERNEL); if ( !s ) { return NULL; } memset( s, 0, sizeof(struct usb_midi_state) ); INIT_LIST_HEAD(&s->midiDevList); INIT_LIST_HEAD(&s->inEndpointList); INIT_LIST_HEAD(&s->outEndpointList); s->usbdev = dev; s->count = 0; spin_lock_init(&s->lock); if ( detect_by_hand( dev, ifnum, s ) && detect_midi_subclass( dev, ifnum, s ) && detect_vendor_specific_device( dev, ifnum, s ) && detect_yamaha_device( dev, ifnum, s) ) { kfree(s); return NULL; } down(&open_sem); list_add_tail(&s->mididev, &mididevs); up(&open_sem); #ifdef MOD_INC_EACH_PROBE MOD_INC_USE_COUNT; #endif return s; } static void usb_midi_disconnect(struct usb_device *dev, void *ptr) { struct usb_midi_state *s = (struct usb_midi_state *)ptr; struct list_head *list; struct usb_mididev *m; if ( s == (struct usb_midi_state *)-1 ) { return; } if ( !s->usbdev ) { return; } down(&open_sem); list_del(&s->mididev); INIT_LIST_HEAD(&s->mididev); s->usbdev = NULL; for ( list = s->midiDevList.next; list != &s->midiDevList; list = list->next ) { m = list_entry(list, struct usb_mididev, list); wake_up(&(m->min.ep->wait)); wake_up(&(m->mout.ep->wait)); if ( m->dev_midi >= 0 ) { unregister_sound_midi(m->dev_midi); } m->dev_midi = -1; } release_midi_device(s); wake_up(&open_wait); #ifdef MOD_INC_EACH_PROBE MOD_DEC_USE_COUNT; #endif return; } static struct usb_driver usb_midi_driver = { name: "midi", probe: usb_midi_probe, disconnect: usb_midi_disconnect, id_table: NULL, /* check all devices */ driver_list: LIST_HEAD_INIT(usb_midi_driver.driver_list) }; /* ------------------------------------------------------------------------- */ int __init usb_midi_init(void) { if ( usb_register(&usb_midi_driver) < 0 ) return -1; return 0; } void __exit usb_midi_exit(void) { usb_deregister(&usb_midi_driver); } module_init(usb_midi_init) ; module_exit(usb_midi_exit) ; #ifdef HAVE_ALSA_SUPPORT #define SNDRV_MAIN_OBJECT_FILE #include "../../include/driver.h" #include "../../include/control.h" #include "../../include/info.h" #include "../../include/cs46xx.h" /* ------------------------------------------------------------------------- */ static int snd_usbmidi_input_close(snd_rawmidi_substream_t * substream) { return 0; } static int snd_usbmidi_input_open(snd_rawmidi_substream_t * substream ) { return 0; } static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t * substream, int up) { return 0; } /* ------------------------------------------------------------------------- */ static int snd_usbmidi_output_close(snd_rawmidi_substream_t * substream) { return 0; } static int snd_usbmidi_output_open(snd_rawmidi_substream_t * substream) { return 0; } static void snd_usb_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { return 0; } /* ------------------------------------------------------------------------- */ static snd_rawmidi_ops_t snd_usbmidi_output = { open: snd_usbmidi_output_open, close: snd_usbmidi_output_close, trigger: snd_usbmidi_output_trigger, }; static snd_rawmidi_ops_t snd_usbmidi_input = { open: snd_usbmidi_input_open, close: snd_usbmidi_input_close, trigger: snd_usbmidi_input_trigger, }; int snd_usbmidi_midi(cs46xx_t *chip, int device, snd_rawmidi_t **rrawmidi) { snd_rawmidi_t *rmidi; int err; if (rrawmidi) *rrawmidi = NULL; if ((err = snd_rawmidi_new(chip->card, "USB-MIDI", device, 1, 1, &rmidi)) < 0) return err; strcpy(rmidi->name, "USB-MIDI"); snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output ); snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usbmidi_input ); rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; rmidi->private_data = chip; chip->rmidi = rmidi; if (rrawmidi) *rrawmidi = NULL; return 0; } int snd_usbmidi_create( snd_card_t * card, struct pci_dev * pci, usbmidi_t ** rchip ) { usbmidi_t *chip; int err, idx; snd_region_t *region; static snd_device_opt_t ops = { dev_free: snd_usbmidi_dev_free, }; *rchip = NULL; chip = snd_magic_kcalloc( usbmidi_t, 0, GFP_KERNEL ); if ( chip == NULL ) return -ENOMEM; } EXPORT_SYMBOL(snd_usbmidi_create); EXPORT_SYMBOL(snd_usbmidi_midi); #endif /* HAVE_ALSA_SUPPORT */