[PATCH] USB: remove .owner field from struct usb_driver
[linux-2.6.git] / drivers / usb / class / usb-midi.c
1 /*
2   usb-midi.c  --  USB-MIDI driver
3
4   Copyright (C) 2001 
5       NAGANO Daisuke <breeze.nagano@nifty.ne.jp>
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2, or (at your option)
10   any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; if not, write to the Free Software
19   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
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
25     - umidi.c for NetBSD
26  */
27
28 /* ------------------------------------------------------------------------- */
29
30
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>
41
42 #include "usb-midi.h"
43
44 /* ------------------------------------------------------------------------- */
45
46 /* More verbose on syslog */
47 #undef MIDI_DEBUG
48
49 #define MIDI_IN_BUFSIZ 1024
50
51 #define HAVE_SUPPORT_USB_MIDI_CLASS
52
53 #undef HAVE_SUPPORT_ALSA
54
55 /* ------------------------------------------------------------------------- */
56
57 static int singlebyte = 0;
58 module_param(singlebyte, int, 0);
59 MODULE_PARM_DESC(singlebyte,"Enable sending MIDI messages with single message packet");
60
61 static int maxdevices = 4;
62 module_param(maxdevices, int, 0);
63 MODULE_PARM_DESC(maxdevices,"Max number of allocatable MIDI device");
64
65 static int uvendor     = -1;
66 module_param(uvendor, int, 0);
67 MODULE_PARM_DESC(uvendor, "The USB Vendor ID of a semi-compliant interface");
68
69 static int uproduct    = -1;
70 module_param(uproduct, int, 0);
71 MODULE_PARM_DESC(uproduct, "The USB Product ID of a semi-compliant interface");
72
73 static int uinterface  = -1;
74 module_param(uinterface, int, 0);
75 MODULE_PARM_DESC(uinterface, "The Interface number of a semi-compliant interface");
76
77 static int ualt        = -1;
78 module_param(ualt, int, 0);
79 MODULE_PARM_DESC(ualt, "The optional alternative setting of a semi-compliant interface");
80
81 static int umin        = -1;
82 module_param(umin, int, 0);
83 MODULE_PARM_DESC(umin, "The input endpoint of a semi-compliant interface");
84
85 static int umout       = -1;
86 module_param(umout, int, 0);
87 MODULE_PARM_DESC(umout, "The output endpoint of a semi-compliant interface");
88
89 static int ucable      = -1;
90 module_param(ucable, int, 0);
91 MODULE_PARM_DESC(ucable, "The cable number used for a semi-compliant interface");
92
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().
96  **/
97 static unsigned short ulangid      = 0x0409; /** 0x0411 for Japanese **/
98 module_param(ulangid, ushort, 0);
99 MODULE_PARM_DESC(ulangid, "The optional preferred USB Language ID for all devices");
100
101 MODULE_AUTHOR("NAGANO Daisuke <breeze.nagano@nifty.ne.jp>");
102 MODULE_DESCRIPTION("USB-MIDI driver");
103 MODULE_LICENSE("GPL");
104
105 /* ------------------------------------------------------------------------- */
106
107 /** MIDIStreaming Class-Specific Interface Descriptor Subtypes **/
108
109 #define MS_DESCRIPTOR_UNDEFINED 0
110 #define MS_HEADER               1
111 #define MIDI_IN_JACK            2
112 #define MIDI_OUT_JACK           3
113 /* Spec reads: ELEMENT */
114 #define ELEMENT_DESCRIPTOR      4
115
116 #define MS_HEADER_LENGTH        7
117
118 /** MIDIStreaming Class-Specific Endpoint Descriptor Subtypes **/
119
120 #define DESCRIPTOR_UNDEFINED    0
121 /* Spec reads: MS_GENERAL */
122 #define MS_GENERAL_ENDPOINT     1
123
124 /** MIDIStreaming MIDI IN and OUT Jack Types **/
125
126 #define JACK_TYPE_UNDEFINED     0
127 /* Spec reads: EMBEDDED */
128 #define EMBEDDED_JACK           1
129 /* Spec reads: EXTERNAL */
130 #define EXTERNAL_JACK           2
131
132
133 /* structure summary
134   
135       usb_midi_state     usb_device
136        |         |
137       *|        *|       per ep
138      in_ep     out_ep
139        |         |
140       *|        *|       per cable
141       min       mout
142        |         |       (cable to device pairing magic)
143        |         |
144        usb_midi_dev      dev_id (major,minor) == file->private_data
145
146 */
147
148 /* usb_midi_state: corresponds to a USB-MIDI module */
149 struct usb_midi_state {
150         struct list_head   mididev;
151         
152         struct usb_device *usbdev;
153         
154         struct list_head   midiDevList;
155         struct list_head   inEndpointList;
156         struct list_head   outEndpointList;
157         
158         spinlock_t         lock;
159         
160         unsigned int       count; /* usage counter */
161 };
162
163 /* midi_out_endpoint: corresponds to an output endpoint */
164 struct midi_out_endpoint {
165         struct list_head  list;
166         
167         struct usb_device *usbdev;
168         int                endpoint;
169         spinlock_t         lock;
170         wait_queue_head_t  wait;
171         
172         unsigned char     *buf;
173         int                bufWrPtr;
174         int                bufSize;
175         
176         struct urb       *urb;
177 };
178
179 /* midi_in_endpoint: corresponds to an input endpoint */
180 struct midi_in_endpoint {
181         struct list_head   list;
182
183         struct usb_device *usbdev;
184         int                endpoint;
185         spinlock_t         lock;
186         wait_queue_head_t  wait;
187
188         struct usb_mididev *cables[16]; // cables open for read
189         int                 readers;    // number of cables open for read
190
191         struct urb        *urb;
192         unsigned char     *recvBuf;
193         int                recvBufSize;
194         int                urbSubmitted;        //FIXME: == readers > 0
195 };
196
197 /* usb_mididev: corresponds to a logical device */
198 struct usb_mididev {
199         struct list_head       list;
200
201         struct usb_midi_state *midi;
202         int                    dev_midi;
203         mode_t                 open_mode;
204
205         struct {
206                 struct midi_in_endpoint *ep;
207                 int              cableId;
208                 
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];
212                 int              bufRdPtr;
213                 int              bufWrPtr;
214                 int              bufRemains;
215         } min;
216
217         struct {
218                 struct midi_out_endpoint *ep;
219                 int              cableId;
220                 
221                 unsigned char    buf[3];
222                 int              bufPtr;
223                 int              bufRemains;
224                 
225                 int              isInExclusive;
226                 unsigned char    lastEvent;
227         } mout;
228
229         int singlebyte;
230 };
231
232 /** Map the high nybble of MIDI voice messages to number of Message bytes.
233  * High nyble ranges from 0x8 to 0xe
234  */
235
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 **/
244 };
245
246 /** Map the messages to a number of Message bytes.
247  *
248  **/
249 static int remains_f0f6[] = {
250         0,      /** 0xF0 **/
251         2,      /** 0XF1 **/
252         3,      /** 0XF2 **/
253         2,      /** 0XF3 **/
254         2,      /** 0XF4 (Undefined by MIDI Spec, and subject to change) **/
255         2,      /** 0XF5 (Undefined by MIDI Spec, and subject to change) **/
256         1       /** 0XF6 **/
257 };
258
259 /** Map the messages to a CIN (Code Index Number).
260  *
261  **/
262 static int cin_f0ff[] = {
263         4,      /** 0xF0 System Exclusive Message Start (special cases may be 6 or 7) */
264         2,      /** 0xF1 **/
265         3,      /** 0xF2 **/
266         2,      /** 0xF3 **/
267         2,      /** 0xF4 **/
268         2,      /** 0xF5 **/
269         5,      /** 0xF6 **/
270         5,      /** 0xF7 End of System Exclusive Message (May be 6 or 7) **/
271         5,      /** 0xF8 **/
272         5,      /** 0xF9 **/
273         5,      /** 0xFA **/
274         5,      /** 0xFB **/
275         5,      /** 0xFC **/
276         5,      /** 0xFD **/
277         5,      /** 0xFE **/
278         5       /** 0xFF **/
279 };
280
281 /** Map MIDIStreaming Event packet Code Index Number (low nybble of byte 0)
282  * to the number of bytes of valid MIDI data.
283  *
284  * CIN of 0 and 1 are NOT USED in MIDIStreaming 1.0.
285  *
286  **/
287 static int cin_to_len[] = {
288         0, 0, 2, 3,
289         3, 1, 2, 3,
290         3, 3, 3, 3,
291         2, 2, 3, 1
292 };
293
294
295 /* ------------------------------------------------------------------------- */
296
297 static struct list_head mididevs = LIST_HEAD_INIT(mididevs);
298
299 static DECLARE_MUTEX(open_sem);
300 static DECLARE_WAIT_QUEUE_HEAD(open_wait);
301
302
303 /* ------------------------------------------------------------------------- */
304
305 static void usb_write_callback(struct urb *urb, struct pt_regs *regs)
306 {
307         struct midi_out_endpoint *ep = (struct midi_out_endpoint *)urb->context;
308
309         if ( waitqueue_active( &ep->wait ) )
310                 wake_up_interruptible( &ep->wait );
311 }
312
313
314 static int usb_write( struct midi_out_endpoint *ep, unsigned char *buf, int len )
315 {
316         struct usb_device *d;
317         int pipe;
318         int ret = 0;
319         int status;
320         int maxretry = 50;
321         
322         DECLARE_WAITQUEUE(wait,current);
323         init_waitqueue_head(&ep->wait);
324
325         d = ep->usbdev;
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 );
329
330         status = usb_submit_urb(ep->urb, GFP_KERNEL);
331     
332         if (status) {
333                 printk(KERN_ERR "usbmidi: Cannot submit urb (%d)\n",status);
334                 ret = -EIO;
335                 goto error;
336         }
337
338         add_wait_queue( &ep->wait, &wait );
339         set_current_state( TASK_INTERRUPTIBLE );
340
341         while( ep->urb->status == -EINPROGRESS ) {
342                 if ( maxretry-- < 0 ) {
343                         printk(KERN_ERR "usbmidi: usb_bulk_msg timed out\n");
344                         ret = -ETIME;
345                         break;
346                 }
347                 interruptible_sleep_on_timeout( &ep->wait, 10 );
348         }
349         set_current_state( TASK_RUNNING );
350         remove_wait_queue( &ep->wait, &wait );
351
352 error:
353         return ret;
354 }
355
356
357 /** Copy data from URB to In endpoint buf.
358  * Discard if CIN == 0 or CIN = 1.
359  *
360  *
361  **/
362
363 static void usb_bulk_read(struct urb *urb, struct pt_regs *regs)
364 {
365         struct midi_in_endpoint *ep = (struct midi_in_endpoint *)(urb->context);
366         unsigned char *data = urb->transfer_buffer;
367         int i, j, wake;
368
369         if ( !ep->urbSubmitted ) {
370                 return;
371         }
372
373         if ( (urb->status == 0) && (urb->actual_length > 0) ) {
374                 wake = 0;
375                 spin_lock( &ep->lock );
376
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];
381                         if ( cable ) {
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;
390                                         wake = 1;
391                                 }
392                         }
393                 }
394
395                 spin_unlock ( &ep->lock );
396                 if ( wake ) {
397                         wake_up( &ep->wait );
398                 }
399         }
400
401         /* urb->dev must be reinitialized on 2.4.x kernels */
402         urb->dev = ep->usbdev;
403
404         urb->actual_length = 0;
405         usb_submit_urb(urb, GFP_ATOMIC);
406 }
407
408
409
410 /* ------------------------------------------------------------------------- */
411
412 /* This routine must be called with spin_lock */
413
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();
417  **/
418 static int flush_midi_buffer( struct midi_out_endpoint *ep )
419 {
420         int ret=0;
421
422         if ( ep->bufWrPtr > 0 ) {
423                 ret = usb_write( ep, ep->buf, ep->bufWrPtr );
424                 ep->bufWrPtr = 0;
425         }
426
427         return ret;
428 }
429
430
431 /* ------------------------------------------------------------------------- */
432
433
434 /** Given a MIDI Event, determine size of data to be attached to 
435  * USB-MIDI packet.
436  * Returns 1, 2 or 3.
437  * Called by midiWrite();
438  * Uses remains_80e0 and remains_f0f6;
439  **/
440 static int get_remains(int event)
441 {
442         int ret;
443
444         if ( event  < 0x80 ) {
445                 ret = 1;
446         } else if ( event < 0xf0 ) {
447                 ret = remains_80e0[((event-0x80)>>4)&0x0f];
448         } else if ( event < 0xf7 ) {
449                 ret = remains_f0f6[event-0xf0];
450         } else {
451                 ret = 1;
452         }
453
454         return ret;
455 }
456
457 /** Given the output MIDI data in the output buffer, computes a reasonable 
458  * CIN.
459  * Called by putOneMidiEvent().
460  **/
461 static int get_CIN( struct usb_mididev *m )
462 {
463         int cin;
464
465         if ( m->mout.buf[0] == 0xf7 ) {
466                 cin = 5;
467         }
468         else if ( m->mout.buf[1] == 0xf7 ) {
469                 cin = 6;
470         }
471         else if ( m->mout.buf[2] == 0xf7 ) {
472                 cin = 7;
473         }
474         else {
475                 if ( m->mout.isInExclusive == 1 ) {
476                         cin = 4;
477                 } else if ( m->mout.buf[0] < 0x80 ) {
478                         /** One byte that we know nothing about. **/
479                         cin = 0xF; 
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; 
483                 }
484                 else {
485                         /** Special lookup table exists for real-time events. **/
486                         cin = cin_f0ff[m->mout.buf[0]-0xf0];
487                 }
488         }
489
490         return cin;
491 }
492
493
494 /* ------------------------------------------------------------------------- */
495
496
497
498 /** Move data to USB endpoint buffer.
499  *
500  **/
501 static int put_one_midi_event(struct usb_mididev *m)
502 {
503         int cin;
504         unsigned long flags;
505         struct midi_out_endpoint *ep = m->mout.ep;
506         int ret=0;
507
508         cin = get_CIN( m );
509         if ( cin > 0x0f || cin < 0 ) {
510                 return -EINVAL;
511         }
512
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 );
520         }
521         spin_unlock_irqrestore( &ep->lock, flags);
522
523         m->mout.buf[0] = m->mout.buf[1] = m->mout.buf[2] = 0;
524         m->mout.bufPtr = 0;
525
526         return ret;
527 }
528
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.
532  **/
533
534 static int midi_write( struct usb_mididev *m, int v )
535 {
536         unsigned long flags;
537         struct midi_out_endpoint *ep = m->mout.ep;
538         int ret=0;
539         unsigned char c = (unsigned char)v;
540         unsigned char sysrt_buf[4];
541
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 );
547                         if ( !ret ) {
548                                 spin_unlock_irqrestore( &ep->lock, flags );
549                                 return ret;
550                         }
551                 }
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 );
558                 }
559                 spin_unlock_irqrestore( &ep->lock, flags );
560
561                 return ret;
562         }
563         /** Normal USB-MIDI protocol begins here. */
564
565         if ( c > 0xf7 ) {       /* system: Realtime messages */
566                 /** Realtime messages are written IMMEDIATELY. */
567                 sysrt_buf[0] = (m->mout.cableId<<4) | 0x0f;
568                 sysrt_buf[1] = c;
569                 sysrt_buf[2] = 0;
570                 sysrt_buf[3] = 0;
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; */
575
576                 return ret;
577         }
578
579         if ( c >= 0x80 ) {
580                 if ( c < 0xf0 ) {
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);
596                 }
597     
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 */
601                 }
602                 /** track status **/
603                 m->mout.buf[0] = m->mout.lastEvent;
604                 m->mout.bufPtr = 1;
605                 m->mout.bufRemains = get_remains(m->mout.lastEvent)-1;
606         }
607   
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);
612         }
613
614         return ret;
615 }
616
617
618 /* ------------------------------------------------------------------------- */
619
620 /** Basic operation on /dev/midiXX as registered through struct file_operations.
621  *
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.
625  *
626  *  Because a MIDIStream is not a file, all seek operations are doomed to fail.
627  *
628  **/
629 static loff_t usb_midi_llseek(struct file *file, loff_t offset, int origin)
630 {
631         /** Tell user you cannot seek on a PIPE-like device. **/
632         return -ESPIPE;
633 }
634
635
636 /** Basic operation on /dev/midiXX as registered through struct file_operations.
637  *
638  * Basic contract: Block until count bytes have been read or an error occurs.
639  *
640  **/
641
642 static ssize_t usb_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
643 {
644         struct usb_mididev *m = (struct usb_mididev *)file->private_data;
645         struct midi_in_endpoint *ep = m->min.ep;
646         ssize_t ret;
647         DECLARE_WAITQUEUE(wait, current);
648
649         if ( !access_ok(VERIFY_READ, buffer, count) ) {
650                 return -EFAULT;
651         }
652         if ( count == 0 ) {
653                 return 0;
654         }
655
656         add_wait_queue( &ep->wait, &wait );
657         ret = 0;
658         while( count > 0 ) {
659                 int cnt;
660                 int d = (int)count;
661
662                 cnt = m->min.bufRemains;
663                 if ( cnt > d ) {
664                         cnt = d;
665                 }
666
667                 if ( cnt <= 0 ) {
668                         if ( file->f_flags & O_NONBLOCK ) {
669                                 if (!ret) 
670                                         ret = -EAGAIN;
671                                 break;
672                         }
673                         __set_current_state(TASK_INTERRUPTIBLE);
674                         schedule();
675                         if (signal_pending(current)) {
676                                 if(!ret)
677                                         ret=-ERESTARTSYS;
678                                 break;
679                         }
680                         continue;
681                 }
682
683                 {
684                         int i;
685                         unsigned long flags; /* used to synchronize access to the endpoint */
686                         spin_lock_irqsave( &ep->lock, flags );
687                         for (i = 0; i < cnt; i++) {
688                                 if ( copy_to_user( buffer+i, m->min.buf+m->min.bufRdPtr, 1 ) ) {
689                                         if ( !ret )
690                                                 ret = -EFAULT;
691                                         break;
692                                 }
693                                 m->min.bufRdPtr = (m->min.bufRdPtr+1)%MIDI_IN_BUFSIZ;
694                                 m->min.bufRemains -= 1;
695                         }
696                         spin_unlock_irqrestore( &ep->lock, flags );
697                 }
698
699                 count-=cnt;
700                 buffer+=cnt;
701                 ret+=cnt;
702
703                 break;
704         }
705
706         remove_wait_queue( &ep->wait, &wait );
707         set_current_state(TASK_RUNNING);
708
709         return ret;
710 }
711
712
713 /** Basic operation on /dev/midiXX as registered through struct file_operations.
714  *
715  *  Basic Contract: Take MIDI data byte-by-byte and pass it to
716  *  writeMidi() which packages MIDI data into USB-MIDI stream.
717  *  Then flushMidiData() is called to ensure all bytes have been written
718  *  in a timely fashion.
719  *
720  **/
721
722 static ssize_t usb_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
723 {
724         struct usb_mididev *m = (struct usb_mididev *)file->private_data;
725         ssize_t ret;
726         unsigned long int flags;
727
728         if ( !access_ok(VERIFY_READ, buffer, count) ) {
729                 return -EFAULT;
730         }
731         if ( count == 0 ) {
732                 return 0;
733         }
734
735         ret = 0;
736         while( count > 0 ) {
737                 unsigned char c;
738
739                 if (copy_from_user((unsigned char *)&c, buffer, 1)) {
740                         if ( ret == 0 )
741                                 ret = -EFAULT;
742                         break;
743                 }
744                 if( midi_write(m, (int)c) ) {
745                         if ( ret == 0 )
746                                 ret = -EFAULT;
747                         break;
748                 }
749                 count--;
750                 buffer++;
751                 ret++;
752         }
753
754         spin_lock_irqsave( &m->mout.ep->lock, flags );
755         if ( flush_midi_buffer(m->mout.ep) < 0 ) {
756                 ret = -EFAULT;
757         }
758         spin_unlock_irqrestore( &m->mout.ep->lock, flags );
759
760         return ret;
761 }
762
763 /** Basic operation on /dev/midiXX as registered through struct file_operations.
764  *
765  * Basic contract:  Wait (spin) until ready to read or write on the file.
766  *
767  **/
768 static unsigned int usb_midi_poll(struct file *file, struct poll_table_struct *wait)
769 {
770         struct usb_mididev *m = (struct usb_mididev *)file->private_data;
771         struct midi_in_endpoint *iep = m->min.ep;
772         struct midi_out_endpoint *oep = m->mout.ep;
773         unsigned long flags;
774         unsigned int mask = 0;
775   
776         if ( file->f_mode & FMODE_READ ) {
777                 poll_wait( file, &iep->wait, wait );
778                 spin_lock_irqsave( &iep->lock, flags );
779                 if ( m->min.bufRemains > 0 )
780                         mask |= POLLIN | POLLRDNORM;
781                 spin_unlock_irqrestore( &iep->lock, flags );
782         }
783
784         if ( file->f_mode & FMODE_WRITE ) {
785                 poll_wait( file, &oep->wait, wait );
786                 spin_lock_irqsave( &oep->lock, flags );
787                 if ( oep->bufWrPtr < oep->bufSize )
788                         mask |= POLLOUT | POLLWRNORM;
789                 spin_unlock_irqrestore( &oep->lock, flags );
790         }
791
792         return mask;
793 }
794
795
796 /** Basic operation on /dev/midiXX as registered through struct file_operations.
797  *
798  * Basic contract: This is always the first operation performed on the
799  * device node. If no method is defined, the open succeeds without any
800  * notification given to the module.
801  *
802  **/
803
804 static int usb_midi_open(struct inode *inode, struct file *file)
805 {
806         int minor = iminor(inode);
807         DECLARE_WAITQUEUE(wait, current);
808         struct usb_midi_state *s;
809         struct usb_mididev    *m;
810         unsigned long flags;
811         int succeed = 0;
812
813 #if 0
814         printk(KERN_INFO "usb-midi: Open minor= %d.\n", minor);
815 #endif
816
817         for(;;) {
818                 down(&open_sem);
819                 list_for_each_entry(s, &mididevs, mididev) {
820                         list_for_each_entry(m, &s->midiDevList, list) {
821                                 if ( !((m->dev_midi ^ minor) & ~0xf) )
822                                         goto device_found;
823                         }
824                 }
825                 up(&open_sem);
826                 return -ENODEV;
827
828         device_found:
829                 if ( !s->usbdev ) {
830                         up(&open_sem);
831                         return -EIO;
832                 }
833                 if ( !(m->open_mode & file->f_mode) ) {
834                         break;
835                 }
836                 if ( file->f_flags & O_NONBLOCK ) {
837                         up(&open_sem);
838                         return -EBUSY;
839                 }
840                 __set_current_state(TASK_INTERRUPTIBLE);
841                 add_wait_queue( &open_wait, &wait );
842                 up(&open_sem);
843                 schedule();
844                 remove_wait_queue( &open_wait, &wait );
845                 if ( signal_pending(current) ) {
846                         return -ERESTARTSYS;
847                 }
848         }
849
850         file->private_data = m;
851         spin_lock_irqsave( &s->lock, flags );
852
853         if ( !(m->open_mode & (FMODE_READ | FMODE_WRITE)) ) {
854                 //FIXME: intented semantics unclear here
855                 m->min.bufRdPtr       = 0;
856                 m->min.bufWrPtr       = 0;
857                 m->min.bufRemains     = 0;
858                 spin_lock_init(&m->min.ep->lock);
859
860                 m->mout.bufPtr        = 0;
861                 m->mout.bufRemains    = 0;
862                 m->mout.isInExclusive = 0;
863                 m->mout.lastEvent     = 0;
864                 spin_lock_init(&m->mout.ep->lock);
865         }
866
867         if ( (file->f_mode & FMODE_READ) && m->min.ep != NULL ) {
868                 unsigned long int flagsep;
869                 spin_lock_irqsave( &m->min.ep->lock, flagsep );
870                 m->min.ep->cables[m->min.cableId] = m;
871                 m->min.ep->readers += 1;
872                 m->min.bufRdPtr       = 0;
873                 m->min.bufWrPtr       = 0;
874                 m->min.bufRemains     = 0;
875                 spin_unlock_irqrestore( &m->min.ep->lock, flagsep );
876
877                 if ( !(m->min.ep->urbSubmitted)) {
878
879                         /* urb->dev must be reinitialized on 2.4.x kernels */
880                         m->min.ep->urb->dev = m->min.ep->usbdev;
881
882                         if ( usb_submit_urb(m->min.ep->urb, GFP_ATOMIC) ) {
883                                 printk(KERN_ERR "usbmidi: Cannot submit urb for MIDI-IN\n");
884                         }
885                         m->min.ep->urbSubmitted = 1;
886                 }
887                 m->open_mode |= FMODE_READ;
888                 succeed = 1;
889         }
890
891         if ( (file->f_mode & FMODE_WRITE) && m->mout.ep != NULL ) {
892                 m->mout.bufPtr        = 0;
893                 m->mout.bufRemains    = 0;
894                 m->mout.isInExclusive = 0;
895                 m->mout.lastEvent     = 0;
896                 m->open_mode |= FMODE_WRITE;
897                 succeed = 1;
898         }
899
900         spin_unlock_irqrestore( &s->lock, flags );
901
902         s->count++;
903         up(&open_sem);
904
905         /** Changed to prevent extra increments to USE_COUNT. **/
906         if (!succeed) {
907                 return -EBUSY;
908         }
909
910 #if 0
911         printk(KERN_INFO "usb-midi: Open Succeeded. minor= %d.\n", minor);
912 #endif
913
914         return nonseekable_open(inode, file); /** Success. **/
915 }
916
917
918 /** Basic operation on /dev/midiXX as registered through struct file_operations.
919  *
920  *  Basic contract: Close an opened file and deallocate anything we allocated.
921  *  Like open(), this can be missing. If open set file->private_data,
922  *  release() must clear it.
923  *
924  **/
925
926 static int usb_midi_release(struct inode *inode, struct file *file)
927 {
928         struct usb_mididev *m = (struct usb_mididev *)file->private_data;
929         struct usb_midi_state *s = (struct usb_midi_state *)m->midi;
930
931 #if 0
932         printk(KERN_INFO "usb-midi: Close.\n");
933 #endif
934
935         down(&open_sem);
936
937         if ( m->open_mode & FMODE_WRITE ) {
938                 m->open_mode &= ~FMODE_WRITE;
939                 usb_kill_urb( m->mout.ep->urb );
940         }
941
942         if ( m->open_mode & FMODE_READ ) {
943                 unsigned long int flagsep;
944                 spin_lock_irqsave( &m->min.ep->lock, flagsep );
945                 m->min.ep->cables[m->min.cableId] = NULL; // discard cable
946                 m->min.ep->readers -= 1;
947                 m->open_mode &= ~FMODE_READ;
948                 if ( m->min.ep->readers == 0 &&
949                      m->min.ep->urbSubmitted ) {
950                         m->min.ep->urbSubmitted = 0;
951                         usb_kill_urb(m->min.ep->urb);
952                 }
953                 spin_unlock_irqrestore( &m->min.ep->lock, flagsep );
954         }
955
956         s->count--;
957
958         up(&open_sem);
959         wake_up(&open_wait);
960
961         file->private_data = NULL;
962         return 0;
963 }
964
965 static struct file_operations usb_midi_fops = {
966         .owner =        THIS_MODULE,
967         .llseek =       usb_midi_llseek,
968         .read =         usb_midi_read,
969         .write =        usb_midi_write,
970         .poll =         usb_midi_poll,
971         .open =         usb_midi_open,
972         .release =      usb_midi_release,
973 };
974
975 /* ------------------------------------------------------------------------- */
976
977 /** Returns filled midi_in_endpoint structure or null on failure.
978  *
979  * Parameters:
980  *      d        - a usb_device
981  *      endPoint - An usb endpoint in the range 0 to 15.
982  * Called by allocUsbMidiDev();
983  *
984  **/
985
986 static struct midi_in_endpoint *alloc_midi_in_endpoint( struct usb_device *d, int endPoint )
987 {
988         struct midi_in_endpoint *ep;
989         int bufSize;
990         int pipe;
991
992         endPoint &= 0x0f; /* Silently force endPoint to lie in range 0 to 15. */
993
994         pipe =  usb_rcvbulkpipe( d, endPoint );
995         bufSize = usb_maxpacket( d, pipe, 0 );
996         /* usb_pipein() = ! usb_pipeout() = true for an in Endpoint */
997
998         ep = (struct midi_in_endpoint *)kmalloc(sizeof(struct midi_in_endpoint), GFP_KERNEL);
999         if ( !ep ) {
1000                 printk(KERN_ERR "usbmidi: no memory for midi in-endpoint\n");
1001                 return NULL;
1002         }
1003         memset( ep, 0, sizeof(struct midi_in_endpoint) );
1004 //      this sets cables[] and readers to 0, too.
1005 //      for (i=0; i<16; i++) ep->cables[i] = 0; // discard cable
1006 //      ep->readers = 0;
1007
1008         ep->endpoint = endPoint;
1009
1010         ep->recvBuf = (unsigned char *)kmalloc(sizeof(unsigned char)*(bufSize), GFP_KERNEL);
1011         if ( !ep->recvBuf ) {
1012                 printk(KERN_ERR "usbmidi: no memory for midi in-endpoint buffer\n");
1013                 kfree(ep);
1014                 return NULL;
1015         }
1016
1017         ep->urb = usb_alloc_urb(0, GFP_KERNEL); /* no ISO */
1018         if ( !ep->urb ) {
1019                 printk(KERN_ERR "usbmidi: no memory for midi in-endpoint urb\n");
1020                 kfree(ep->recvBuf);
1021                 kfree(ep);
1022                 return NULL;
1023         }
1024         usb_fill_bulk_urb( ep->urb, d, 
1025                        usb_rcvbulkpipe(d, endPoint),
1026                        (unsigned char *)ep->recvBuf, bufSize,
1027                        usb_bulk_read, ep );
1028
1029         /* ep->bufRdPtr     = 0; */
1030         /* ep->bufWrPtr     = 0; */
1031         /* ep->bufRemains   = 0; */
1032         /* ep->urbSubmitted = 0; */
1033         ep->recvBufSize  = bufSize;
1034
1035         init_waitqueue_head(&ep->wait);
1036
1037         return ep;
1038 }
1039
1040 static int remove_midi_in_endpoint( struct midi_in_endpoint *min )
1041 {
1042         usb_kill_urb( min->urb );
1043         usb_free_urb( min->urb );
1044         kfree( min->recvBuf );
1045         kfree( min );
1046
1047         return 0;
1048 }
1049
1050 /** Returns filled midi_out_endpoint structure or null on failure.
1051  *
1052  * Parameters:
1053  *      d        - a usb_device
1054  *      endPoint - An usb endpoint in the range 0 to 15.
1055  * Called by allocUsbMidiDev();
1056  *
1057  **/
1058 static struct midi_out_endpoint *alloc_midi_out_endpoint( struct usb_device *d, int endPoint )
1059 {
1060         struct midi_out_endpoint *ep = NULL;
1061         int pipe;
1062         int bufSize;
1063
1064         endPoint &= 0x0f;
1065         pipe =  usb_sndbulkpipe( d, endPoint );
1066         bufSize = usb_maxpacket( d, pipe, 1 );
1067
1068         ep = (struct midi_out_endpoint *)kmalloc(sizeof(struct midi_out_endpoint), GFP_KERNEL);
1069         if ( !ep ) {
1070                 printk(KERN_ERR "usbmidi: no memory for midi out-endpoint\n");
1071                 return NULL;
1072         }
1073         memset( ep, 0, sizeof(struct midi_out_endpoint) );
1074
1075         ep->endpoint = endPoint;
1076         ep->buf = (unsigned char *)kmalloc(sizeof(unsigned char)*bufSize, GFP_KERNEL);
1077         if ( !ep->buf ) {
1078                 printk(KERN_ERR "usbmidi: no memory for midi out-endpoint buffer\n");
1079                 kfree(ep);
1080                 return NULL;
1081         }
1082
1083         ep->urb = usb_alloc_urb(0, GFP_KERNEL); /* no ISO */
1084         if ( !ep->urb ) {
1085                 printk(KERN_ERR "usbmidi: no memory for midi out-endpoint urb\n");
1086                 kfree(ep->buf);
1087                 kfree(ep);
1088                 return NULL;
1089         }
1090
1091         ep->bufSize       = bufSize;
1092         /* ep->bufWrPtr      = 0; */
1093
1094         init_waitqueue_head(&ep->wait);
1095
1096         return ep;
1097 }
1098
1099
1100 static int remove_midi_out_endpoint( struct midi_out_endpoint *mout )
1101 {
1102         usb_kill_urb( mout->urb );
1103         usb_free_urb( mout->urb );
1104         kfree( mout->buf );
1105         kfree( mout );
1106
1107         return 0;
1108 }
1109
1110
1111 /** Returns a filled usb_mididev structure, registered as a Linux MIDI device.
1112  *
1113  * Returns null if memory is not available or the device cannot be registered.
1114  * Called by allocUsbMidiDev();
1115  *
1116  **/
1117 static struct usb_mididev *allocMidiDev(
1118         struct usb_midi_state *s,
1119         struct midi_in_endpoint *min,
1120         struct midi_out_endpoint *mout,
1121         int inCableId,
1122         int outCableId )
1123 {
1124         struct usb_mididev *m;
1125
1126         m = (struct usb_mididev *)kmalloc(sizeof(struct usb_mididev), GFP_KERNEL);
1127         if (!m) {
1128                 printk(KERN_ERR "usbmidi: no memory for midi device\n");
1129                 return NULL;
1130         }
1131
1132         memset(m, 0, sizeof(struct usb_mididev));
1133
1134         if ((m->dev_midi = register_sound_midi(&usb_midi_fops, -1)) < 0) {
1135                 printk(KERN_ERR "usbmidi: cannot register midi device\n");
1136                 kfree(m);
1137                 return NULL;
1138         }
1139
1140         m->midi               = s;
1141         /* m->open_mode          = 0; */
1142
1143         if ( min ) {
1144                 m->min.ep             = min;
1145                 m->min.ep->usbdev     = s->usbdev;
1146                 m->min.cableId        = inCableId;
1147         }
1148         /* m->min.bufPtr         = 0; */
1149         /* m->min.bufRemains     = 0; */
1150
1151         if ( mout ) {
1152                 m->mout.ep            = mout;
1153                 m->mout.ep->usbdev    = s->usbdev;
1154                 m->mout.cableId       = outCableId;
1155         }
1156         /* m->mout.bufPtr        = 0; */
1157         /* m->mout.bufRemains    = 0; */
1158         /* m->mout.isInExclusive = 0; */
1159         /* m->mout.lastEvent     = 0; */
1160
1161         m->singlebyte         = singlebyte;
1162
1163         return m;
1164 }
1165
1166
1167 static void release_midi_device( struct usb_midi_state *s )
1168 {
1169         struct usb_mididev *m;
1170         struct midi_in_endpoint *min;
1171         struct midi_out_endpoint *mout;
1172
1173         if ( s->count > 0 ) {
1174                 up(&open_sem);
1175                 return;
1176         }
1177         up( &open_sem );
1178         wake_up( &open_wait );
1179
1180         while(!list_empty(&s->inEndpointList)) {
1181                 min = list_entry(s->inEndpointList.next, struct midi_in_endpoint, list);
1182                 list_del(&min->list);
1183                 remove_midi_in_endpoint(min);
1184         }
1185
1186         while(!list_empty(&s->outEndpointList)) {
1187                 mout = list_entry(s->outEndpointList.next, struct midi_out_endpoint, list);
1188                 list_del(&mout->list);
1189                 remove_midi_out_endpoint(mout);
1190         }
1191
1192         while(!list_empty(&s->midiDevList)) {
1193                 m = list_entry(s->midiDevList.next, struct usb_mididev, list);
1194                 list_del(&m->list);
1195                 kfree(m);
1196         }
1197
1198         kfree(s);
1199
1200         return;
1201 }
1202
1203
1204 /* ------------------------------------------------------------------------- */
1205
1206 /** Utility routine to find a descriptor in a dump of many descriptors.
1207  * Returns start of descriptor or NULL if not found. 
1208  * descStart pointer to list of interfaces.
1209  * descLength length (in bytes) of dump
1210  * after (ignored if NULL) this routine returns only descriptors after "after"
1211  * dtype (mandatory) The descriptor type.
1212  * iface (ignored if -1) returns descriptor at/following given interface
1213  * altSetting (ignored if -1) returns descriptor at/following given altSetting
1214  *
1215  *
1216  *  Called by parseDescriptor(), find_csinterface_descriptor();
1217  *
1218  */
1219 static void *find_descriptor( void *descStart, unsigned int descLength, void *after, unsigned char dtype, int iface, int altSetting )
1220 {
1221         unsigned char *p, *end, *next;
1222         int interfaceNumber = -1, altSet = -1;
1223
1224         p = descStart;
1225         end = p + descLength;
1226         for( ; p < end; ) {
1227                 if ( p[0] < 2 )
1228                         return NULL;
1229                 next = p + p[0];
1230                 if ( next > end )
1231                         return NULL;
1232                 if ( p[1] == USB_DT_INTERFACE ) {
1233                         if ( p[0] < USB_DT_INTERFACE_SIZE )
1234                                 return NULL;
1235                         interfaceNumber = p[2];
1236                         altSet = p[3];
1237                 }
1238                 if ( p[1] == dtype &&
1239                      ( !after || ( p > (unsigned char *)after) ) &&
1240                      ( ( iface == -1) || (iface == interfaceNumber) ) &&
1241                      ( (altSetting == -1) || (altSetting == altSet) )) {
1242                         return p;
1243                 }
1244                 p = next;
1245         }
1246         return NULL;
1247 }
1248
1249 /** Utility to find a class-specific interface descriptor.
1250  *  dsubtype is a descriptor subtype
1251  *  Called by parseDescriptor();
1252  **/
1253 static void *find_csinterface_descriptor(void *descStart, unsigned int descLength, void *after, u8 dsubtype, int iface, int altSetting)
1254 {
1255         unsigned char *p;
1256   
1257         p = find_descriptor( descStart, descLength, after, USB_DT_CS_INTERFACE, iface, altSetting );
1258         while ( p ) {
1259                 if ( p[0] >= 3 && p[2] == dsubtype )
1260                         return p;
1261                 p = find_descriptor( descStart, descLength, p, USB_DT_CS_INTERFACE, 
1262                                      iface, altSetting );
1263         }
1264         return NULL;
1265 }
1266
1267
1268 /** The magic of making a new usb_midi_device from config happens here.
1269  *
1270  * The caller is responsible for free-ing this return value (if not NULL).
1271  *
1272  **/
1273 static struct usb_midi_device *parse_descriptor( struct usb_device *d, unsigned char *buffer, int bufSize, unsigned int ifnum , unsigned int altSetting, int quirks)
1274 {
1275         struct usb_midi_device *u;
1276         unsigned char *p1;
1277         unsigned char *p2;
1278         unsigned char *next;
1279         int iep, oep;
1280         int length;
1281         unsigned long longBits;
1282         int pins, nbytes, offset, shift, jack;
1283 #ifdef HAVE_JACK_STRINGS
1284         /** Jacks can have associated names.  **/
1285         unsigned char jack2string[256];
1286 #endif
1287
1288         u = NULL;
1289         /* find audiocontrol interface */
1290         p1 = find_csinterface_descriptor( buffer, bufSize, NULL,
1291                                           MS_HEADER, ifnum, altSetting);
1292
1293         if ( !p1 ) {
1294                 goto error_end;
1295         }
1296
1297         if ( p1[0] < MS_HEADER_LENGTH ) {
1298                 goto error_end;
1299         }
1300
1301         /* Assume success. Since the device corresponds to USB-MIDI spec, we assume
1302            that the rest of the USB 2.0 spec is obeyed. */
1303
1304         u = (struct usb_midi_device *)kmalloc( sizeof(struct usb_midi_device), GFP_KERNEL );
1305         if ( !u ) {
1306                 return NULL;
1307         }
1308         u->deviceName = NULL;
1309         u->idVendor = le16_to_cpu(d->descriptor.idVendor);
1310         u->idProduct = le16_to_cpu(d->descriptor.idProduct);
1311         u->interface = ifnum;
1312         u->altSetting = altSetting;
1313         u->in[0].endpoint = -1;
1314         u->in[0].cableId = -1;
1315         u->out[0].endpoint = -1;
1316         u->out[0].cableId = -1;
1317
1318
1319         printk(KERN_INFO "usb-midi: Found MIDIStreaming device corresponding to Release %d.%02d of spec.\n",
1320                (p1[4] >> 4) * 10 + (p1[4] & 0x0f ),
1321                (p1[3] >> 4) * 10 + (p1[3] & 0x0f )
1322                 );
1323
1324         length = p1[5] | (p1[6] << 8);
1325
1326 #ifdef HAVE_JACK_STRINGS
1327         memset(jack2string, 0, sizeof(unsigned char) * 256);
1328 #endif
1329
1330         length -= p1[0];
1331         for (p2 = p1 + p1[0]; length > 0; p2 = next) {
1332                 next = p2 + p2[0];
1333                 length -= p2[0];
1334
1335                 if (p2[0] < 2 )
1336                         break;
1337                 if (p2[1] != USB_DT_CS_INTERFACE)
1338                         break;
1339                 if (p2[2] == MIDI_IN_JACK && p2[0] >= 6 ) {
1340                         jack = p2[4];
1341 #ifdef HAVE_JACK_STRINGS
1342                         jack2string[jack] = p2[5];
1343 #endif
1344                         printk(KERN_INFO "usb-midi: Found IN Jack 0x%02x %s\n",
1345                                jack, (p2[3] == EMBEDDED_JACK)?"EMBEDDED":"EXTERNAL" );
1346                 } else if ( p2[2] == MIDI_OUT_JACK && p2[0] >= 6) {
1347                         pins = p2[5];
1348                         if ( p2[0] < (6 + 2 * pins) )
1349                                 continue;
1350                         jack = p2[4];
1351 #ifdef HAVE_JACK_STRINGS
1352                         jack2string[jack] = p2[5 + 2 * pins];
1353 #endif
1354                         printk(KERN_INFO "usb-midi: Found OUT Jack 0x%02x %s, %d pins\n",
1355                                jack, (p2[3] == EMBEDDED_JACK)?"EMBEDDED":"EXTERNAL", pins );
1356                 } else if ( p2[2] == ELEMENT_DESCRIPTOR  && p2[0]  >= 10) {
1357                         pins = p2[4];
1358                         if ( p2[0] < (9 + 2 * pins ) )
1359                                 continue;
1360                         nbytes = p2[8 + 2 * pins ];
1361                         if ( p2[0] < (10 + 2 * pins + nbytes) )
1362                                 continue;
1363                         longBits = 0L;
1364                         for ( offset = 0, shift = 0; offset < nbytes && offset < 8; offset ++, shift += 8) {
1365                                 longBits |= ((long)(p2[9 + 2 * pins + offset])) << shift;
1366                         }
1367                         jack = p2[3];
1368 #ifdef HAVE_JACK_STRINGS
1369                         jack2string[jack] = p2[9 + 2 * pins + nbytes];
1370 #endif
1371                         printk(KERN_INFO "usb-midi: Found ELEMENT 0x%02x, %d/%d pins in/out, bits: 0x%016lx\n",
1372                                jack, pins, (int)(p2[5 + 2 * pins]), (long)longBits );
1373                 } else {
1374                 }
1375         }
1376
1377         iep=0;
1378         oep=0;
1379
1380         if (quirks==0) {
1381                 /* MIDISTREAM */
1382                 p2 = NULL;
1383                 for (p1 = find_descriptor(buffer, bufSize, NULL, USB_DT_ENDPOINT,
1384                                           ifnum, altSetting ); p1; p1 = next ) {
1385                         next = find_descriptor(buffer, bufSize, p1, USB_DT_ENDPOINT,
1386                                                ifnum, altSetting ); 
1387                         p2 = find_descriptor(buffer, bufSize, p1, USB_DT_CS_ENDPOINT,
1388                                              ifnum, altSetting ); 
1389
1390                         if ( p2 && next && ( p2 > next ) )
1391                                 p2 = NULL;
1392
1393                         if ( p1[0] < 9 || !p2 || p2[0] < 4 )
1394                                 continue;
1395
1396                         if ( (p1[2] & 0x80) == 0x80 ) {
1397                                 if ( iep < 15 ) {
1398                                         pins = p2[3]; /* not pins -- actually "cables" */
1399                                         if ( pins > 16 )
1400                                                 pins = 16;
1401                                         u->in[iep].endpoint = p1[2];
1402                                         u->in[iep].cableId = ( 1 << pins ) - 1;
1403                                         if ( u->in[iep].cableId )
1404                                                 iep ++;
1405                                         if ( iep < 15 ) {
1406                                                 u->in[iep].endpoint = -1;
1407                                                 u->in[iep].cableId = -1;
1408                                         }
1409                                 }
1410                         } else {
1411                                 if ( oep < 15 ) {
1412                                         pins = p2[3]; /* not pins -- actually "cables" */
1413                                         if ( pins > 16 )
1414                                                 pins = 16;
1415                                         u->out[oep].endpoint = p1[2];
1416                                         u->out[oep].cableId = ( 1 << pins ) - 1;
1417                                         if ( u->out[oep].cableId )
1418                                                 oep ++;
1419                                         if ( oep < 15 ) {
1420                                                 u->out[oep].endpoint = -1;
1421                                                 u->out[oep].cableId = -1;
1422                                         }
1423                                 }
1424                         }
1425         
1426                 }
1427         } else if (quirks==1) {
1428                 /* YAMAHA quirks */
1429                 for (p1 = find_descriptor(buffer, bufSize, NULL, USB_DT_ENDPOINT,
1430                                           ifnum, altSetting ); p1; p1 = next ) {
1431                         next = find_descriptor(buffer, bufSize, p1, USB_DT_ENDPOINT,
1432                                                ifnum, altSetting ); 
1433         
1434                         if ( p1[0] < 7 )
1435                                 continue;
1436
1437                         if ( (p1[2] & 0x80) == 0x80 ) {
1438                                 if ( iep < 15 ) {
1439                                         pins = iep+1;
1440                                         if ( pins > 16 )
1441                                                 pins = 16;
1442                                         u->in[iep].endpoint = p1[2];
1443                                         u->in[iep].cableId = ( 1 << pins ) - 1;
1444                                         if ( u->in[iep].cableId )
1445                                                 iep ++;
1446                                         if ( iep < 15 ) {
1447                                                 u->in[iep].endpoint = -1;
1448                                                 u->in[iep].cableId = -1;
1449                                         }
1450                                 }
1451                         } else {
1452                                 if ( oep < 15 ) {
1453                                         pins = oep+1;
1454                                         u->out[oep].endpoint = p1[2];
1455                                         u->out[oep].cableId = ( 1 << pins ) - 1;
1456                                         if ( u->out[oep].cableId )
1457                                                 oep ++;
1458                                         if ( oep < 15 ) {
1459                                                 u->out[oep].endpoint = -1;
1460                                                 u->out[oep].cableId = -1;
1461                                         }
1462                                 }
1463                         }
1464         
1465                 }
1466         }
1467
1468         if ( !iep && ! oep ) {
1469                 goto error_end;
1470         }
1471
1472         return u;
1473
1474 error_end:
1475         kfree(u);
1476         return NULL;
1477 }
1478
1479 /* ------------------------------------------------------------------------- */
1480
1481 /** Returns number between 0 and 16.
1482  *
1483  **/
1484 static int on_bits( unsigned short v )
1485 {
1486         int i;
1487         int ret=0;
1488
1489         for ( i=0 ; i<16 ; i++ ) {
1490                 if ( v & (1<<i) )
1491                         ret++;
1492         }
1493
1494         return ret;
1495 }
1496
1497
1498 /** USB-device will be interrogated for altSetting.
1499  *
1500  * Returns negative on error.
1501  * Called by allocUsbMidiDev();
1502  *
1503  **/
1504
1505 static int get_alt_setting( struct usb_device *d, int ifnum )
1506 {
1507         int alts, alt=0;
1508         struct usb_interface *iface;
1509         struct usb_host_interface *interface;
1510         struct usb_endpoint_descriptor *ep;
1511         int epin, epout;
1512         int i;
1513
1514         iface = usb_ifnum_to_if( d, ifnum );
1515         alts = iface->num_altsetting;
1516
1517         for ( alt=0 ; alt<alts ; alt++ ) {
1518                 interface = &iface->altsetting[alt];
1519                 epin = -1;
1520                 epout = -1;
1521
1522                 for ( i=0 ; i<interface->desc.bNumEndpoints ; i++ ) {
1523                         ep = &interface->endpoint[i].desc;
1524                         if ( (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ) {
1525                                 continue;
1526                         }
1527                         if ( (ep->bEndpointAddress & USB_DIR_IN) && epin < 0 ) {
1528                                 epin = i;
1529                         } else if ( epout < 0 ) {
1530                                 epout = i;
1531                         }
1532                         if ( epin >= 0 && epout >= 0 ) {
1533                                 return interface->desc.bAlternateSetting;
1534                         }
1535                 }
1536         }
1537
1538         return -ENODEV;
1539 }
1540
1541
1542 /* ------------------------------------------------------------------------- */
1543
1544
1545 /** Returns 0 if successful in allocating and registering internal structures.
1546  * Returns negative on failure.
1547  * Calls allocMidiDev which additionally registers /dev/midiXX devices.
1548  * Writes messages on success to indicate which /dev/midiXX is which physical
1549  * endpoint.
1550  *
1551  **/
1552 static int alloc_usb_midi_device( struct usb_device *d, struct usb_midi_state *s, struct usb_midi_device *u )
1553 {
1554         struct usb_mididev **mdevs=NULL;
1555         struct midi_in_endpoint *mins[15], *min;
1556         struct midi_out_endpoint *mouts[15], *mout;
1557         int inDevs=0, outDevs=0;
1558         int inEndpoints=0, outEndpoints=0;
1559         int inEndpoint, outEndpoint;
1560         int inCableId, outCableId;
1561         int i;
1562         int devices = 0;
1563         int alt = 0;
1564
1565         /* Obtain altSetting or die.. */
1566         alt = u->altSetting;
1567         if ( alt < 0 ) {
1568                 alt = get_alt_setting( d, u->interface );
1569         }
1570         if ( alt < 0 )
1571                 return -ENXIO;
1572
1573         /* Configure interface */
1574         if ( usb_set_interface( d, u->interface, alt ) < 0 ) {
1575                 return -ENXIO;
1576         }
1577
1578         for ( i = 0 ; i < 15 ; i++ ) {
1579                 mins[i] = NULL;
1580                 mouts[i] = NULL;
1581         }
1582
1583         /* Begin Allocation */
1584         while( inEndpoints < 15
1585                && inDevs < maxdevices
1586                && u->in[inEndpoints].cableId >= 0 ) {
1587                 inDevs += on_bits((unsigned short)u->in[inEndpoints].cableId);
1588                 mins[inEndpoints] = alloc_midi_in_endpoint( d, u->in[inEndpoints].endpoint );
1589                 if ( mins[inEndpoints] == NULL )
1590                         goto error_end;
1591                 inEndpoints++;
1592         }
1593
1594         while( outEndpoints < 15
1595                && outDevs < maxdevices
1596                && u->out[outEndpoints].cableId >= 0 ) {
1597                 outDevs += on_bits((unsigned short)u->out[outEndpoints].cableId);
1598                 mouts[outEndpoints] = alloc_midi_out_endpoint( d, u->out[outEndpoints].endpoint );
1599                 if ( mouts[outEndpoints] == NULL )
1600                         goto error_end;
1601                 outEndpoints++;
1602         }
1603
1604         devices = inDevs > outDevs ? inDevs : outDevs;
1605         devices = maxdevices > devices ? devices : maxdevices;
1606
1607         /* obtain space for device name (iProduct) if not known. */
1608         if ( ! u->deviceName ) {
1609                 mdevs = (struct usb_mididev **)
1610                         kmalloc(sizeof(struct usb_mididevs *)*devices
1611                                 + sizeof(char) * 256, GFP_KERNEL);
1612         } else {
1613                 mdevs = (struct usb_mididev **)
1614                         kmalloc(sizeof(struct usb_mididevs *)*devices, GFP_KERNEL);
1615         }
1616
1617         if ( !mdevs ) {
1618                 /* devices = 0; */
1619                 /* mdevs = NULL; */
1620                 goto error_end;
1621         }
1622         for ( i=0 ; i<devices ; i++ ) {
1623                 mdevs[i] = NULL;
1624         }
1625
1626         /* obtain device name (iProduct) if not known. */
1627         if ( ! u->deviceName ) {
1628                 u->deviceName = (char *) (mdevs + devices);
1629                 if ( ! d->have_langid && d->descriptor.iProduct) {
1630                         alt = usb_get_string(d, 0, 0, u->deviceName, 250);
1631                         if (alt < 0) {
1632                                 printk(KERN_INFO "error getting string descriptor 0 (error=%d)\n", alt);
1633                         } else if (u->deviceName[0] < 4) {
1634                                 printk(KERN_INFO "string descriptor 0 too short (length = %d)\n", alt);
1635                         } else {
1636                                 printk(KERN_INFO "string descriptor 0 found (length = %d)\n", alt);
1637                                 for(; alt >= 4; alt -= 2) {
1638                                         i = u->deviceName[alt-2] | (u->deviceName[alt-1]<< 8);
1639                                         printk(KERN_INFO "usb-midi: langid(%d) 0x%04x\n",
1640                                                (alt-4) >> 1, i);
1641                                         if ( ( ( i ^ ulangid ) & 0xff ) == 0 ) {
1642                                                 d->have_langid = 1;
1643                                                 d->string_langid = i;
1644                                                 printk(KERN_INFO "usb-midi: langid(match) 0x%04x\n", i);
1645                                                 if ( i == ulangid )
1646                                                         break;
1647                                         }
1648                                 }
1649                         }
1650                 }
1651                 u->deviceName[0] = (char) 0;
1652                 if (d->descriptor.iProduct) {
1653                         printk(KERN_INFO "usb-midi: fetchString(%d)\n", d->descriptor.iProduct);
1654                         alt = usb_string(d, d->descriptor.iProduct, u->deviceName, 255);
1655                         if( alt < 0 ) {
1656                                 u->deviceName[0] = (char) 0;
1657                         }
1658                         printk(KERN_INFO "usb-midi: fetchString = %d\n", alt);
1659                 } 
1660                 /* Failsafe */
1661                 if ( !u->deviceName[0] ) {
1662                         if (le16_to_cpu(d->descriptor.idVendor) == USB_VENDOR_ID_ROLAND ) {
1663                                 strcpy(u->deviceName, "Unknown Roland");
1664                         } else if (le16_to_cpu(d->descriptor.idVendor) == USB_VENDOR_ID_STEINBERG  ) {
1665                                 strcpy(u->deviceName, "Unknown Steinberg");
1666                         } else if (le16_to_cpu(d->descriptor.idVendor) == USB_VENDOR_ID_YAMAHA ) {
1667                                 strcpy(u->deviceName, "Unknown Yamaha");
1668                         } else {
1669                                 strcpy(u->deviceName, "Unknown");
1670                         }
1671                 }
1672         }
1673
1674         inEndpoint  = 0; inCableId  = -1;
1675         outEndpoint = 0; outCableId = -1;
1676
1677         for ( i=0 ; i<devices ; i++ ) {
1678                 for ( inCableId ++ ;
1679                       inEndpoint <15
1680                               && mins[inEndpoint] 
1681                               && !(u->in[inEndpoint].cableId & (1<<inCableId)) ;
1682                       inCableId++ ) {
1683                         if ( inCableId >= 16 ) {
1684                                 inEndpoint  ++;
1685                                 inCableId  = 0;
1686                         }
1687                 }
1688                 min  = mins[inEndpoint];
1689                 for ( outCableId ++ ;
1690                       outEndpoint <15
1691                               && mouts[outEndpoint] 
1692                               && !(u->out[outEndpoint].cableId & (1<<outCableId)) ;
1693                       outCableId++ ) {
1694                         if ( outCableId >= 16 ) {
1695                                 outEndpoint  ++;
1696                                 outCableId  = 0;
1697                         }
1698                 }
1699                 mout = mouts[outEndpoint];
1700
1701                 mdevs[i] = allocMidiDev( s, min, mout, inCableId, outCableId );
1702                 if ( mdevs[i] == NULL )
1703                         goto error_end;
1704
1705         }
1706
1707         /* Success! */
1708         for ( i=0 ; i<devices ; i++ ) {
1709                 list_add_tail( &mdevs[i]->list, &s->midiDevList );
1710         }
1711         for ( i=0 ; i<inEndpoints ; i++ ) {
1712                 list_add_tail( &mins[i]->list, &s->inEndpointList );
1713         }
1714         for ( i=0 ; i<outEndpoints ; i++ ) {
1715                 list_add_tail( &mouts[i]->list, &s->outEndpointList );
1716         }
1717
1718         printk(KERN_INFO "usbmidi: found [ %s ] (0x%04x:0x%04x), attached:\n", u->deviceName, u->idVendor, u->idProduct );
1719         for ( i=0 ; i<devices ; i++ ) {
1720                 int dm = (mdevs[i]->dev_midi-2)>>4;
1721                 if ( mdevs[i]->mout.ep != NULL && mdevs[i]->min.ep != NULL ) {
1722                         printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%2d) out (ep:%02x cid:%2d bufsiz:%2d)\n", 
1723                                dm,
1724                                mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize,
1725                                mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize);
1726                 } else if ( mdevs[i]->min.ep != NULL ) {
1727                         printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%02d)\n", 
1728                                dm,
1729                                mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize);
1730                 } else if ( mdevs[i]->mout.ep != NULL ) {
1731                         printk(KERN_INFO "usbmidi: /dev/midi%02d: out (ep:%02x cid:%2d bufsiz:%02d)\n", 
1732                                dm,
1733                                mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize);
1734                 }
1735         }
1736
1737         kfree(mdevs);
1738         return 0;
1739
1740  error_end:
1741         if ( mdevs != NULL ) {
1742                 for ( i=0 ; i<devices ; i++ ) {
1743                         if ( mdevs[i] != NULL ) {
1744                                 unregister_sound_midi( mdevs[i]->dev_midi );
1745                                 kfree(mdevs[i]);
1746                         }
1747                 }
1748                 kfree(mdevs);
1749         }
1750
1751         for ( i=0 ; i<15 ; i++ ) {
1752                 if ( mins[i] != NULL ) {
1753                         remove_midi_in_endpoint( mins[i] );
1754                 }
1755                 if ( mouts[i] != NULL ) {
1756                         remove_midi_out_endpoint( mouts[i] );
1757                 }
1758         }
1759
1760         return -ENOMEM;
1761 }
1762
1763 /* ------------------------------------------------------------------------- */
1764
1765 /** Attempt to scan YAMAHA's device descriptor and detect correct values of
1766  *  them.
1767  *  Return 0 on succes, negative on failure.
1768  *  Called by usb_midi_probe();
1769  **/
1770
1771 static int detect_yamaha_device( struct usb_device *d,
1772                 struct usb_interface *iface, unsigned int ifnum,
1773                 struct usb_midi_state *s)
1774 {
1775         struct usb_host_interface *interface;
1776         struct usb_midi_device *u;
1777         unsigned char *buffer;
1778         int bufSize;
1779         int i;
1780         int alts=-1;
1781         int ret;
1782
1783         if (le16_to_cpu(d->descriptor.idVendor) != USB_VENDOR_ID_YAMAHA) {
1784                 return -EINVAL;
1785         }
1786
1787         for ( i=0 ; i < iface->num_altsetting; i++ ) {
1788                 interface = iface->altsetting + i;
1789
1790                 if ( interface->desc.bInterfaceClass != 255 ||
1791                      interface->desc.bInterfaceSubClass != 0 )
1792                         continue;
1793                 alts = interface->desc.bAlternateSetting;
1794         }
1795         if ( alts == -1 ) {
1796                 return -EINVAL;
1797         }
1798
1799         printk(KERN_INFO "usb-midi: Found YAMAHA USB-MIDI device on dev %04x:%04x, iface %d\n",
1800                le16_to_cpu(d->descriptor.idVendor),
1801                le16_to_cpu(d->descriptor.idProduct), ifnum);
1802
1803         i = d->actconfig - d->config;
1804         buffer = d->rawdescriptors[i];
1805         bufSize = le16_to_cpu(d->actconfig->desc.wTotalLength);
1806
1807         u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 1);
1808         if ( u == NULL ) {
1809                 return -EINVAL;
1810         }
1811
1812         ret = alloc_usb_midi_device( d, s, u );
1813
1814         kfree(u);
1815
1816         return ret;
1817 }
1818
1819
1820 /** Scan table of known devices which are only partially compliant with 
1821  * the MIDIStreaming specification.
1822  * Called by usb_midi_probe();
1823  *
1824  **/
1825
1826 static int detect_vendor_specific_device( struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s )
1827 {
1828         struct usb_midi_device *u;
1829         int i;
1830         int ret = -ENXIO;
1831
1832         for ( i=0; i<VENDOR_SPECIFIC_USB_MIDI_DEVICES ; i++ ) {
1833                 u=&(usb_midi_devices[i]);
1834     
1835                 if ( le16_to_cpu(d->descriptor.idVendor) != u->idVendor ||
1836                      le16_to_cpu(d->descriptor.idProduct) != u->idProduct ||
1837                      ifnum != u->interface )
1838                         continue;
1839
1840                 ret = alloc_usb_midi_device( d, s, u );
1841                 break;
1842         }
1843
1844         return ret;
1845 }
1846
1847
1848 /** Attempt to match any config of an interface to a MIDISTREAMING interface.
1849  *  Returns 0 on success, negative on failure.
1850  * Called by usb_midi_probe();
1851  **/
1852 static int detect_midi_subclass(struct usb_device *d,
1853                 struct usb_interface *iface, unsigned int ifnum,
1854                 struct usb_midi_state *s)
1855 {
1856         struct usb_host_interface *interface;
1857         struct usb_midi_device *u;
1858         unsigned char *buffer;
1859         int bufSize;
1860         int i;
1861         int alts=-1;
1862         int ret;
1863
1864         for ( i=0 ; i < iface->num_altsetting; i++ ) {
1865                 interface = iface->altsetting + i;
1866
1867                 if ( interface->desc.bInterfaceClass != USB_CLASS_AUDIO ||
1868                      interface->desc.bInterfaceSubClass != USB_SUBCLASS_MIDISTREAMING )
1869                         continue;
1870                 alts = interface->desc.bAlternateSetting;
1871         }
1872         if ( alts == -1 ) {
1873                 return -EINVAL;
1874         }
1875
1876         printk(KERN_INFO "usb-midi: Found MIDISTREAMING on dev %04x:%04x, iface %d\n",
1877                le16_to_cpu(d->descriptor.idVendor), 
1878                le16_to_cpu(d->descriptor.idProduct), ifnum);
1879
1880
1881         /* From USB Spec v2.0, Section 9.5.
1882            If the class or vendor specific descriptors use the same format
1883            as standard descriptors (e.g., start with a length byte and
1884            followed by a type byte), they must be returned interleaved with
1885            standard descriptors in the configuration information returned by
1886            a GetDescriptor(Configuration) request. In this case, the class
1887            or vendor-specific descriptors must follow a related standard
1888            descriptor they modify or extend.
1889         */
1890
1891         i = d->actconfig - d->config;
1892         buffer = d->rawdescriptors[i];
1893         bufSize = le16_to_cpu(d->actconfig->desc.wTotalLength);
1894
1895         u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 0);
1896         if ( u == NULL ) {
1897                 return -EINVAL;
1898         }
1899
1900         ret = alloc_usb_midi_device( d, s, u );
1901
1902         kfree(u);
1903
1904         return ret;
1905 }
1906
1907
1908 /** When user has requested a specific device, match it exactly.
1909  *
1910  * Uses uvendor, uproduct, uinterface, ualt, umin, umout and ucable.
1911  * Called by usb_midi_probe();
1912  *
1913  **/
1914 static int detect_by_hand(struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s)
1915 {
1916         struct usb_midi_device u;
1917
1918         if ( le16_to_cpu(d->descriptor.idVendor) != uvendor ||
1919              le16_to_cpu(d->descriptor.idProduct) != uproduct ||
1920              ifnum != uinterface ) {
1921                 return -EINVAL;
1922         }
1923
1924         if ( ualt < 0 )
1925                 ualt = -1;
1926
1927         if ( umin   < 0 || umin   > 15 )
1928                 umin   = 0x01 | USB_DIR_IN;
1929         if ( umout  < 0 || umout  > 15 )
1930                 umout  = 0x01;
1931         if ( ucable < 0 || ucable > 15 )
1932                 ucable = 0;
1933
1934         u.deviceName = NULL; /* A flag for alloc_usb_midi_device to get device
1935                                 name from device. */
1936         u.idVendor   = uvendor;
1937         u.idProduct  = uproduct;
1938         u.interface  = uinterface;
1939         u.altSetting = ualt;
1940
1941         u.in[0].endpoint    = umin;
1942         u.in[0].cableId     = (1<<ucable);
1943
1944         u.out[0].endpoint   = umout;
1945         u.out[0].cableId    = (1<<ucable);
1946
1947         return alloc_usb_midi_device( d, s, &u );
1948 }
1949
1950
1951
1952 /* ------------------------------------------------------------------------- */
1953
1954 static int usb_midi_probe(struct usb_interface *intf, 
1955                           const struct usb_device_id *id)
1956 {
1957         struct usb_midi_state *s;
1958         struct usb_device *dev = interface_to_usbdev(intf);
1959         int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1960
1961         s = (struct usb_midi_state *)kmalloc(sizeof(struct usb_midi_state), GFP_KERNEL);
1962         if ( !s )
1963                 return -ENOMEM;
1964
1965         memset( s, 0, sizeof(struct usb_midi_state) );
1966         INIT_LIST_HEAD(&s->midiDevList);
1967         INIT_LIST_HEAD(&s->inEndpointList);
1968         INIT_LIST_HEAD(&s->outEndpointList);
1969         s->usbdev = dev;
1970         s->count  = 0;
1971         spin_lock_init(&s->lock);
1972
1973         if (
1974                 detect_by_hand( dev, ifnum, s ) &&
1975                 detect_midi_subclass( dev, intf, ifnum, s ) &&
1976                 detect_vendor_specific_device( dev, ifnum, s ) &&
1977                 detect_yamaha_device( dev, intf, ifnum, s) ) {
1978                 kfree(s);
1979                 return -EIO;
1980         }
1981
1982         down(&open_sem);
1983         list_add_tail(&s->mididev, &mididevs);
1984         up(&open_sem);
1985
1986         usb_set_intfdata (intf, s);
1987         return 0;
1988 }
1989
1990
1991 static void usb_midi_disconnect(struct usb_interface *intf)
1992 {
1993         struct usb_midi_state *s = usb_get_intfdata (intf);
1994         struct usb_mididev    *m;
1995
1996         if ( !s )
1997                 return;
1998
1999         if ( s == (struct usb_midi_state *)-1 ) {
2000                 return;
2001         }
2002         if ( !s->usbdev ) {
2003                 return;
2004         }
2005         down(&open_sem);
2006         list_del(&s->mididev);
2007         INIT_LIST_HEAD(&s->mididev);
2008         s->usbdev = NULL;
2009         usb_set_intfdata (intf, NULL);
2010
2011         list_for_each_entry(m, &s->midiDevList, list) {
2012                 wake_up(&(m->min.ep->wait));
2013                 wake_up(&(m->mout.ep->wait));
2014                 if ( m->dev_midi >= 0 ) {
2015                         unregister_sound_midi(m->dev_midi);
2016                 }
2017                 m->dev_midi = -1;
2018         }
2019         release_midi_device(s);
2020         wake_up(&open_wait);
2021 }
2022
2023 /* we want to look at all devices by hand */
2024 static struct usb_device_id id_table[] = {
2025         {.driver_info = 42},
2026         {}
2027 };
2028
2029 static struct usb_driver usb_midi_driver = {
2030         .name =         "midi",
2031         .probe =        usb_midi_probe,
2032         .disconnect =   usb_midi_disconnect,
2033         .id_table =     id_table,
2034 };
2035
2036 /* ------------------------------------------------------------------------- */
2037
2038 static int __init usb_midi_init(void)
2039 {
2040         return usb_register(&usb_midi_driver);
2041 }
2042
2043 static void __exit usb_midi_exit(void)
2044 {
2045         usb_deregister(&usb_midi_driver);
2046 }
2047
2048 module_init(usb_midi_init) ;
2049 module_exit(usb_midi_exit) ;
2050
2051 #ifdef HAVE_ALSA_SUPPORT
2052 #define SNDRV_MAIN_OBJECT_FILE
2053 #include "../../include/driver.h"
2054 #include "../../include/control.h"
2055 #include "../../include/info.h"
2056 #include "../../include/cs46xx.h"
2057
2058 /* ------------------------------------------------------------------------- */
2059
2060 static int snd_usbmidi_input_close(snd_rawmidi_substream_t * substream)
2061 {
2062         return 0;
2063 }
2064
2065 static int snd_usbmidi_input_open(snd_rawmidi_substream_t * substream )
2066 {
2067         return 0;
2068 }
2069
2070 static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t * substream, int up)
2071 {
2072         return 0;
2073 }
2074
2075
2076 /* ------------------------------------------------------------------------- */
2077
2078 static int snd_usbmidi_output_close(snd_rawmidi_substream_t * substream)
2079 {
2080         return 0;
2081 }
2082
2083 static int snd_usbmidi_output_open(snd_rawmidi_substream_t * substream)
2084 {
2085         return 0;
2086 }
2087
2088 static void snd_usb_midi_output_trigger(snd_rawmidi_substream_t * substream,
2089                                         int up)
2090 {
2091         return 0;
2092 }
2093
2094 /* ------------------------------------------------------------------------- */
2095
2096 static snd_rawmidi_ops_t snd_usbmidi_output =
2097 {
2098         .open =         snd_usbmidi_output_open,
2099         .close =        snd_usbmidi_output_close,
2100         .trigger =      snd_usbmidi_output_trigger,
2101 };
2102 static snd_rawmidi_ops_t snd_usbmidi_input =
2103 {
2104         .open =         snd_usbmidi_input_open,
2105         .close =        snd_usbmidi_input_close,
2106         .trigger =      snd_usbmidi_input_trigger,
2107 };
2108
2109 int snd_usbmidi_midi(cs46xx_t *chip, int device, snd_rawmidi_t **rrawmidi)
2110 {
2111         snd_rawmidi_t *rmidi;
2112         int err;
2113
2114         if (rrawmidi)
2115                 *rrawmidi = NULL;
2116         if ((err = snd_rawmidi_new(chip->card, "USB-MIDI", device, 1, 1, &rmidi)) < 0)
2117                 return err;
2118         strcpy(rmidi->name, "USB-MIDI");
2119
2120         snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output );
2121         snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usbmidi_input );
2122
2123         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
2124
2125         rmidi->private_data = chip;
2126         chip->rmidi = rmidi;
2127         if (rrawmidi)
2128                 *rrawmidi = NULL;
2129
2130         return 0;
2131 }
2132
2133 int snd_usbmidi_create( snd_card_t * card,
2134                         struct pci_dev * pci,
2135                         usbmidi_t ** rchip )
2136 {
2137         usbmidi_t *chip;
2138         int err, idx;
2139         snd_region_t *region;
2140         static snd_device_opt_t ops = {
2141                 .dev_free = snd_usbmidi_dev_free,
2142         };
2143
2144         *rchip = NULL;
2145         chip = snd_magic_kcalloc( usbmidi_t, 0, GFP_KERNEL );
2146         if ( chip == NULL )
2147                 return -ENOMEM;
2148 }
2149
2150 EXPORT_SYMBOL(snd_usbmidi_create);
2151 EXPORT_SYMBOL(snd_usbmidi_midi);
2152 #endif /* HAVE_ALSA_SUPPORT */
2153