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