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, usb_pipein(pipe) );
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, usb_pipeout(pipe) );
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 if ( pins > 16 )
1455 pins = 16;
1456 u->out[oep].endpoint = p1[2];
1457 u->out[oep].cableId = ( 1 << pins ) - 1;
1458 if ( u->out[oep].cableId )
1459 oep ++;
1460 if ( oep < 15 ) {
1461 u->out[oep].endpoint = -1;
1462 u->out[oep].cableId = -1;
1463 }
1464 }
1465 }
1466
1467 }
1468 }
1469
1470 if ( !iep && ! oep ) {
1471 goto error_end;
1472 }
1473
1474 return u;
1475
1476 error_end:
1477 kfree(u);
1478 return NULL;
1479 }
1480
1481 /* ------------------------------------------------------------------------- */
1482
1483 /** Returns number between 0 and 16.
1484 *
1485 **/
1486 static int on_bits( unsigned short v )
1487 {
1488 int i;
1489 int ret=0;
1490
1491 for ( i=0 ; i<16 ; i++ ) {
1492 if ( v & (1<<i) )
1493 ret++;
1494 }
1495
1496 return ret;
1497 }
1498
1499
1500 /** USB-device will be interrogated for altSetting.
1501 *
1502 * Returns negative on error.
1503 * Called by allocUsbMidiDev();
1504 *
1505 **/
1506
1507 static int get_alt_setting( struct usb_device *d, int ifnum )
1508 {
1509 int alts, alt=0;
1510 struct usb_interface *iface;
1511 struct usb_host_interface *interface;
1512 struct usb_endpoint_descriptor *ep;
1513 int epin, epout;
1514 int i;
1515
1516 iface = usb_ifnum_to_if( d, ifnum );
1517 alts = iface->num_altsetting;
1518
1519 for ( alt=0 ; alt<alts ; alt++ ) {
1520 interface = &iface->altsetting[alt];
1521 epin = -1;
1522 epout = -1;
1523
1524 for ( i=0 ; i<interface->desc.bNumEndpoints ; i++ ) {
1525 ep = &interface->endpoint[i].desc;
1526 if ( (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK ) {
1527 continue;
1528 }
1529 if ( (ep->bEndpointAddress & USB_DIR_IN) && epin < 0 ) {
1530 epin = i;
1531 } else if ( epout < 0 ) {
1532 epout = i;
1533 }
1534 if ( epin >= 0 && epout >= 0 ) {
1535 return interface->desc.bAlternateSetting;
1536 }
1537 }
1538 }
1539
1540 return -ENODEV;
1541 }
1542
1543
1544 /* ------------------------------------------------------------------------- */
1545
1546
1547 /** Returns 0 if successful in allocating and registering internal structures.
1548 * Returns negative on failure.
1549 * Calls allocMidiDev which additionally registers /dev/midiXX devices.
1550 * Writes messages on success to indicate which /dev/midiXX is which physical
1551 * endpoint.
1552 *
1553 **/
1554 static int alloc_usb_midi_device( struct usb_device *d, struct usb_midi_state *s, struct usb_midi_device *u )
1555 {
1556 struct usb_mididev **mdevs=NULL;
1557 struct midi_in_endpoint *mins[15], *min;
1558 struct midi_out_endpoint *mouts[15], *mout;
1559 int inDevs=0, outDevs=0;
1560 int inEndpoints=0, outEndpoints=0;
1561 int inEndpoint, outEndpoint;
1562 int inCableId, outCableId;
1563 int i;
1564 int devices = 0;
1565 int alt = 0;
1566
1567 /* Obtain altSetting or die.. */
1568 alt = u->altSetting;
1569 if ( alt < 0 ) {
1570 alt = get_alt_setting( d, u->interface );
1571 }
1572 if ( alt < 0 )
1573 return -ENXIO;
1574
1575 /* Configure interface */
1576 if ( usb_set_interface( d, u->interface, alt ) < 0 ) {
1577 return -ENXIO;
1578 }
1579
1580 for ( i = 0 ; i < 15 ; i++ ) {
1581 mins[i] = NULL;
1582 mouts[i] = NULL;
1583 }
1584
1585 /* Begin Allocation */
1586 while( inEndpoints < 15
1587 && inDevs < maxdevices
1588 && u->in[inEndpoints].cableId >= 0 ) {
1589 inDevs += on_bits((unsigned short)u->in[inEndpoints].cableId);
1590 mins[inEndpoints] = alloc_midi_in_endpoint( d, u->in[inEndpoints].endpoint );
1591 if ( mins[inEndpoints] == NULL )
1592 goto error_end;
1593 inEndpoints++;
1594 }
1595
1596 while( outEndpoints < 15
1597 && outDevs < maxdevices
1598 && u->out[outEndpoints].cableId >= 0 ) {
1599 outDevs += on_bits((unsigned short)u->out[outEndpoints].cableId);
1600 mouts[outEndpoints] = alloc_midi_out_endpoint( d, u->out[outEndpoints].endpoint );
1601 if ( mouts[outEndpoints] == NULL )
1602 goto error_end;
1603 outEndpoints++;
1604 }
1605
1606 devices = inDevs > outDevs ? inDevs : outDevs;
1607 devices = maxdevices > devices ? devices : maxdevices;
1608
1609 /* obtain space for device name (iProduct) if not known. */
1610 if ( ! u->deviceName ) {
1611 mdevs = (struct usb_mididev **)
1612 kmalloc(sizeof(struct usb_mididevs *)*devices
1613 + sizeof(char) * 256, GFP_KERNEL);
1614 } else {
1615 mdevs = (struct usb_mididev **)
1616 kmalloc(sizeof(struct usb_mididevs *)*devices, GFP_KERNEL);
1617 }
1618
1619 if ( !mdevs ) {
1620 /* devices = 0; */
1621 /* mdevs = NULL; */
1622 goto error_end;
1623 }
1624 for ( i=0 ; i<devices ; i++ ) {
1625 mdevs[i] = NULL;
1626 }
1627
1628 /* obtain device name (iProduct) if not known. */
1629 if ( ! u->deviceName ) {
1630 u->deviceName = (char *) (mdevs + devices);
1631 if ( ! d->have_langid && d->descriptor.iProduct) {
1632 alt = usb_get_string(d, 0, 0, u->deviceName, 250);
1633 if (alt < 0) {
1634 printk(KERN_INFO "error getting string descriptor 0 (error=%d)\n", alt);
1635 } else if (u->deviceName[0] < 4) {
1636 printk(KERN_INFO "string descriptor 0 too short (length = %d)\n", alt);
1637 } else {
1638 printk(KERN_INFO "string descriptor 0 found (length = %d)\n", alt);
1639 for(; alt >= 4; alt -= 2) {
1640 i = u->deviceName[alt-2] | (u->deviceName[alt-1]<< 8);
1641 printk(KERN_INFO "usb-midi: langid(%d) 0x%04x\n",
1642 (alt-4) >> 1, i);
1643 if ( ( ( i ^ ulangid ) & 0xff ) == 0 ) {
1644 d->have_langid = 1;
1645 d->string_langid = i;
1646 printk(KERN_INFO "usb-midi: langid(match) 0x%04x\n", i);
1647 if ( i == ulangid )
1648 break;
1649 }
1650 }
1651 }
1652 }
1653 u->deviceName[0] = (char) 0;
1654 if (d->descriptor.iProduct) {
1655 printk(KERN_INFO "usb-midi: fetchString(%d)\n", d->descriptor.iProduct);
1656 alt = usb_string(d, d->descriptor.iProduct, u->deviceName, 255);
1657 if( alt < 0 ) {
1658 u->deviceName[0] = (char) 0;
1659 }
1660 printk(KERN_INFO "usb-midi: fetchString = %d\n", alt);
1661 }
1662 /* Failsafe */
1663 if ( !u->deviceName[0] ) {
1664 if (le16_to_cpu(d->descriptor.idVendor) == USB_VENDOR_ID_ROLAND ) {
1665 strcpy(u->deviceName, "Unknown Roland");
1666 } else if (le16_to_cpu(d->descriptor.idVendor) == USB_VENDOR_ID_STEINBERG ) {
1667 strcpy(u->deviceName, "Unknown Steinberg");
1668 } else if (le16_to_cpu(d->descriptor.idVendor) == USB_VENDOR_ID_YAMAHA ) {
1669 strcpy(u->deviceName, "Unknown Yamaha");
1670 } else {
1671 strcpy(u->deviceName, "Unknown");
1672 }
1673 }
1674 }
1675
1676 inEndpoint = 0; inCableId = -1;
1677 outEndpoint = 0; outCableId = -1;
1678
1679 for ( i=0 ; i<devices ; i++ ) {
1680 for ( inCableId ++ ;
1681 inEndpoint <15
1682 && mins[inEndpoint]
1683 && !(u->in[inEndpoint].cableId & (1<<inCableId)) ;
1684 inCableId++ ) {
1685 if ( inCableId >= 16 ) {
1686 inEndpoint ++;
1687 inCableId = 0;
1688 }
1689 }
1690 min = mins[inEndpoint];
1691 for ( outCableId ++ ;
1692 outEndpoint <15
1693 && mouts[outEndpoint]
1694 && !(u->out[outEndpoint].cableId & (1<<outCableId)) ;
1695 outCableId++ ) {
1696 if ( outCableId >= 16 ) {
1697 outEndpoint ++;
1698 outCableId = 0;
1699 }
1700 }
1701 mout = mouts[outEndpoint];
1702
1703 mdevs[i] = allocMidiDev( s, min, mout, inCableId, outCableId );
1704 if ( mdevs[i] == NULL )
1705 goto error_end;
1706
1707 }
1708
1709 /* Success! */
1710 for ( i=0 ; i<devices ; i++ ) {
1711 list_add_tail( &mdevs[i]->list, &s->midiDevList );
1712 }
1713 for ( i=0 ; i<inEndpoints ; i++ ) {
1714 list_add_tail( &mins[i]->list, &s->inEndpointList );
1715 }
1716 for ( i=0 ; i<outEndpoints ; i++ ) {
1717 list_add_tail( &mouts[i]->list, &s->outEndpointList );
1718 }
1719
1720 printk(KERN_INFO "usbmidi: found [ %s ] (0x%04x:0x%04x), attached:\n", u->deviceName, u->idVendor, u->idProduct );
1721 for ( i=0 ; i<devices ; i++ ) {
1722 int dm = (mdevs[i]->dev_midi-2)>>4;
1723 if ( mdevs[i]->mout.ep != NULL && mdevs[i]->min.ep != NULL ) {
1724 printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%2d) out (ep:%02x cid:%2d bufsiz:%2d)\n",
1725 dm,
1726 mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize,
1727 mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize);
1728 } else if ( mdevs[i]->min.ep != NULL ) {
1729 printk(KERN_INFO "usbmidi: /dev/midi%02d: in (ep:%02x cid:%2d bufsiz:%02d)\n",
1730 dm,
1731 mdevs[i]->min.ep->endpoint|USB_DIR_IN, mdevs[i]->min.cableId, mdevs[i]->min.ep->recvBufSize);
1732 } else if ( mdevs[i]->mout.ep != NULL ) {
1733 printk(KERN_INFO "usbmidi: /dev/midi%02d: out (ep:%02x cid:%2d bufsiz:%02d)\n",
1734 dm,
1735 mdevs[i]->mout.ep->endpoint, mdevs[i]->mout.cableId, mdevs[i]->mout.ep->bufSize);
1736 }
1737 }
1738
1739 kfree(mdevs);
1740 return 0;
1741
1742 error_end:
1743 if ( mdevs != NULL ) {
1744 for ( i=0 ; i<devices ; i++ ) {
1745 if ( mdevs[i] != NULL ) {
1746 unregister_sound_midi( mdevs[i]->dev_midi );
1747 kfree(mdevs[i]);
1748 }
1749 }
1750 kfree(mdevs);
1751 }
1752
1753 for ( i=0 ; i<15 ; i++ ) {
1754 if ( mins[i] != NULL ) {
1755 remove_midi_in_endpoint( mins[i] );
1756 }
1757 if ( mouts[i] != NULL ) {
1758 remove_midi_out_endpoint( mouts[i] );
1759 }
1760 }
1761
1762 return -ENOMEM;
1763 }
1764
1765 /* ------------------------------------------------------------------------- */
1766
1767 /** Attempt to scan YAMAHA's device descriptor and detect correct values of
1768 * them.
1769 * Return 0 on succes, negative on failure.
1770 * Called by usb_midi_probe();
1771 **/
1772
1773 static int detect_yamaha_device( struct usb_device *d,
1774 struct usb_interface *iface, unsigned int ifnum,
1775 struct usb_midi_state *s)
1776 {
1777 struct usb_host_interface *interface;
1778 struct usb_midi_device *u;
1779 unsigned char *buffer;
1780 int bufSize;
1781 int i;
1782 int alts=-1;
1783 int ret;
1784
1785 if (le16_to_cpu(d->descriptor.idVendor) != USB_VENDOR_ID_YAMAHA) {
1786 return -EINVAL;
1787 }
1788
1789 for ( i=0 ; i < iface->num_altsetting; i++ ) {
1790 interface = iface->altsetting + i;
1791
1792 if ( interface->desc.bInterfaceClass != 255 ||
1793 interface->desc.bInterfaceSubClass != 0 )
1794 continue;
1795 alts = interface->desc.bAlternateSetting;
1796 }
1797 if ( alts == -1 ) {
1798 return -EINVAL;
1799 }
1800
1801 printk(KERN_INFO "usb-midi: Found YAMAHA USB-MIDI device on dev %04x:%04x, iface %d\n",
1802 le16_to_cpu(d->descriptor.idVendor),
1803 le16_to_cpu(d->descriptor.idProduct), ifnum);
1804
1805 i = d->actconfig - d->config;
1806 buffer = d->rawdescriptors[i];
1807 bufSize = le16_to_cpu(d->actconfig->desc.wTotalLength);
1808
1809 u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 1);
1810 if ( u == NULL ) {
1811 return -EINVAL;
1812 }
1813
1814 ret = alloc_usb_midi_device( d, s, u );
1815
1816 kfree(u);
1817
1818 return ret;
1819 }
1820
1821
1822 /** Scan table of known devices which are only partially compliant with
1823 * the MIDIStreaming specification.
1824 * Called by usb_midi_probe();
1825 *
1826 **/
1827
1828 static int detect_vendor_specific_device( struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s )
1829 {
1830 struct usb_midi_device *u;
1831 int i;
1832 int ret = -ENXIO;
1833
1834 for ( i=0; i<VENDOR_SPECIFIC_USB_MIDI_DEVICES ; i++ ) {
1835 u=&(usb_midi_devices[i]);
1836
1837 if ( le16_to_cpu(d->descriptor.idVendor) != u->idVendor ||
1838 le16_to_cpu(d->descriptor.idProduct) != u->idProduct ||
1839 ifnum != u->interface )
1840 continue;
1841
1842 ret = alloc_usb_midi_device( d, s, u );
1843 break;
1844 }
1845
1846 return ret;
1847 }
1848
1849
1850 /** Attempt to match any config of an interface to a MIDISTREAMING interface.
1851 * Returns 0 on success, negative on failure.
1852 * Called by usb_midi_probe();
1853 **/
1854 static int detect_midi_subclass(struct usb_device *d,
1855 struct usb_interface *iface, unsigned int ifnum,
1856 struct usb_midi_state *s)
1857 {
1858 struct usb_host_interface *interface;
1859 struct usb_midi_device *u;
1860 unsigned char *buffer;
1861 int bufSize;
1862 int i;
1863 int alts=-1;
1864 int ret;
1865
1866 for ( i=0 ; i < iface->num_altsetting; i++ ) {
1867 interface = iface->altsetting + i;
1868
1869 if ( interface->desc.bInterfaceClass != USB_CLASS_AUDIO ||
1870 interface->desc.bInterfaceSubClass != USB_SUBCLASS_MIDISTREAMING )
1871 continue;
1872 alts = interface->desc.bAlternateSetting;
1873 }
1874 if ( alts == -1 ) {
1875 return -EINVAL;
1876 }
1877
1878 printk(KERN_INFO "usb-midi: Found MIDISTREAMING on dev %04x:%04x, iface %d\n",
1879 le16_to_cpu(d->descriptor.idVendor),
1880 le16_to_cpu(d->descriptor.idProduct), ifnum);
1881
1882
1883 /* From USB Spec v2.0, Section 9.5.
1884 If the class or vendor specific descriptors use the same format
1885 as standard descriptors (e.g., start with a length byte and
1886 followed by a type byte), they must be returned interleaved with
1887 standard descriptors in the configuration information returned by
1888 a GetDescriptor(Configuration) request. In this case, the class
1889 or vendor-specific descriptors must follow a related standard
1890 descriptor they modify or extend.
1891 */
1892
1893 i = d->actconfig - d->config;
1894 buffer = d->rawdescriptors[i];
1895 bufSize = le16_to_cpu(d->actconfig->desc.wTotalLength);
1896
1897 u = parse_descriptor( d, buffer, bufSize, ifnum, alts, 0);
1898 if ( u == NULL ) {
1899 return -EINVAL;
1900 }
1901
1902 ret = alloc_usb_midi_device( d, s, u );
1903
1904 kfree(u);
1905
1906 return ret;
1907 }
1908
1909
1910 /** When user has requested a specific device, match it exactly.
1911 *
1912 * Uses uvendor, uproduct, uinterface, ualt, umin, umout and ucable.
1913 * Called by usb_midi_probe();
1914 *
1915 **/
1916 static int detect_by_hand(struct usb_device *d, unsigned int ifnum, struct usb_midi_state *s)
1917 {
1918 struct usb_midi_device u;
1919
1920 if ( le16_to_cpu(d->descriptor.idVendor) != uvendor ||
1921 le16_to_cpu(d->descriptor.idProduct) != uproduct ||
1922 ifnum != uinterface ) {
1923 return -EINVAL;
1924 }
1925
1926 if ( ualt < 0 )
1927 ualt = -1;
1928
1929 if ( umin < 0 || umin > 15 )
1930 umin = 0x01 | USB_DIR_IN;
1931 if ( umout < 0 || umout > 15 )
1932 umout = 0x01;
1933 if ( ucable < 0 || ucable > 15 )
1934 ucable = 0;
1935
1936 u.deviceName = NULL; /* A flag for alloc_usb_midi_device to get device
1937 name from device. */
1938 u.idVendor = uvendor;
1939 u.idProduct = uproduct;
1940 u.interface = uinterface;
1941 u.altSetting = ualt;
1942
1943 u.in[0].endpoint = umin;
1944 u.in[0].cableId = (1<<ucable);
1945
1946 u.out[0].endpoint = umout;
1947 u.out[0].cableId = (1<<ucable);
1948
1949 return alloc_usb_midi_device( d, s, &u );
1950 }
1951
1952
1953
1954 /* ------------------------------------------------------------------------- */
1955
1956 static int usb_midi_probe(struct usb_interface *intf,
1957 const struct usb_device_id *id)
1958 {
1959 struct usb_midi_state *s;
1960 struct usb_device *dev = interface_to_usbdev(intf);
1961 int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1962
1963 s = (struct usb_midi_state *)kmalloc(sizeof(struct usb_midi_state), GFP_KERNEL);
1964 if ( !s )
1965 return -ENOMEM;
1966
1967 memset( s, 0, sizeof(struct usb_midi_state) );
1968 INIT_LIST_HEAD(&s->midiDevList);
1969 INIT_LIST_HEAD(&s->inEndpointList);
1970 INIT_LIST_HEAD(&s->outEndpointList);
1971 s->usbdev = dev;
1972 s->count = 0;
1973 spin_lock_init(&s->lock);
1974
1975 if (
1976 detect_by_hand( dev, ifnum, s ) &&
1977 detect_midi_subclass( dev, intf, ifnum, s ) &&
1978 detect_vendor_specific_device( dev, ifnum, s ) &&
1979 detect_yamaha_device( dev, intf, ifnum, s) ) {
1980 kfree(s);
1981 return -EIO;
1982 }
1983
1984 down(&open_sem);
1985 list_add_tail(&s->mididev, &mididevs);
1986 up(&open_sem);
1987
1988 usb_set_intfdata (intf, s);
1989 return 0;
1990 }
1991
1992
1993 static void usb_midi_disconnect(struct usb_interface *intf)
1994 {
1995 struct usb_midi_state *s = usb_get_intfdata (intf);
1996 struct usb_mididev *m;
1997
1998 if ( !s )
1999 return;
2000
2001 if ( s == (struct usb_midi_state *)-1 ) {
2002 return;
2003 }
2004 if ( !s->usbdev ) {
2005 return;
2006 }
2007 down(&open_sem);
2008 list_del(&s->mididev);
2009 INIT_LIST_HEAD(&s->mididev);
2010 s->usbdev = NULL;
2011 usb_set_intfdata (intf, NULL);
2012
2013 list_for_each_entry(m, &s->midiDevList, list) {
2014 wake_up(&(m->min.ep->wait));
2015 wake_up(&(m->mout.ep->wait));
2016 if ( m->dev_midi >= 0 ) {
2017 unregister_sound_midi(m->dev_midi);
2018 }
2019 m->dev_midi = -1;
2020 }
2021 release_midi_device(s);
2022 wake_up(&open_wait);
2023 }
2024
2025 /* we want to look at all devices by hand */
2026 static struct usb_device_id id_table[] = {
2027 {.driver_info = 42},
2028 {}
2029 };
2030
2031 static struct usb_driver usb_midi_driver = {
2032 .owner = THIS_MODULE,
2033 .name = "midi",
2034 .probe = usb_midi_probe,
2035 .disconnect = usb_midi_disconnect,
2036 .id_table = id_table,
2037 };
2038
2039 /* ------------------------------------------------------------------------- */
2040
2041 static int __init usb_midi_init(void)
2042 {
2043 return usb_register(&usb_midi_driver);
2044 }
2045
2046 static void __exit usb_midi_exit(void)
2047 {
2048 usb_deregister(&usb_midi_driver);
2049 }
2050
2051 module_init(usb_midi_init) ;
2052 module_exit(usb_midi_exit) ;
2053
2054 #ifdef HAVE_ALSA_SUPPORT
2055 #define SNDRV_MAIN_OBJECT_FILE
2056 #include "../../include/driver.h"
2057 #include "../../include/control.h"
2058 #include "../../include/info.h"
2059 #include "../../include/cs46xx.h"
2060
2061 /* ------------------------------------------------------------------------- */
2062
2063 static int snd_usbmidi_input_close(snd_rawmidi_substream_t * substream)
2064 {
2065 return 0;
2066 }
2067
2068 static int snd_usbmidi_input_open(snd_rawmidi_substream_t * substream )
2069 {
2070 return 0;
2071 }
2072
2073 static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t * substream, int up)
2074 {
2075 return 0;
2076 }
2077
2078
2079 /* ------------------------------------------------------------------------- */
2080
2081 static int snd_usbmidi_output_close(snd_rawmidi_substream_t * substream)
2082 {
2083 return 0;
2084 }
2085
2086 static int snd_usbmidi_output_open(snd_rawmidi_substream_t * substream)
2087 {
2088 return 0;
2089 }
2090
2091 static void snd_usb_midi_output_trigger(snd_rawmidi_substream_t * substream,
2092 int up)
2093 {
2094 return 0;
2095 }
2096
2097 /* ------------------------------------------------------------------------- */
2098
2099 static snd_rawmidi_ops_t snd_usbmidi_output =
2100 {
2101 .open = snd_usbmidi_output_open,
2102 .close = snd_usbmidi_output_close,
2103 .trigger = snd_usbmidi_output_trigger,
2104 };
2105 static snd_rawmidi_ops_t snd_usbmidi_input =
2106 {
2107 .open = snd_usbmidi_input_open,
2108 .close = snd_usbmidi_input_close,
2109 .trigger = snd_usbmidi_input_trigger,
2110 };
2111
2112 int snd_usbmidi_midi(cs46xx_t *chip, int device, snd_rawmidi_t **rrawmidi)
2113 {
2114 snd_rawmidi_t *rmidi;
2115 int err;
2116
2117 if (rrawmidi)
2118 *rrawmidi = NULL;
2119 if ((err = snd_rawmidi_new(chip->card, "USB-MIDI", device, 1, 1, &rmidi)) < 0)
2120 return err;
2121 strcpy(rmidi->name, "USB-MIDI");
2122
2123 snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output );
2124 snd_rawmidi_set_ops( rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usbmidi_input );
2125
2126 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
2127
2128 rmidi->private_data = chip;
2129 chip->rmidi = rmidi;
2130 if (rrawmidi)
2131 *rrawmidi = NULL;
2132
2133 return 0;
2134 }
2135
2136 int snd_usbmidi_create( snd_card_t * card,
2137 struct pci_dev * pci,
2138 usbmidi_t ** rchip )
2139 {
2140 usbmidi_t *chip;
2141 int err, idx;
2142 snd_region_t *region;
2143 static snd_device_opt_t ops = {
2144 .dev_free = snd_usbmidi_dev_free,
2145 };
2146
2147 *rchip = NULL;
2148 chip = snd_magic_kcalloc( usbmidi_t, 0, GFP_KERNEL );
2149 if ( chip == NULL )
2150 return -ENOMEM;
2151 }
2152
2153 EXPORT_SYMBOL(snd_usbmidi_create);
2154 EXPORT_SYMBOL(snd_usbmidi_midi);
2155 #endif /* HAVE_ALSA_SUPPORT */
2156
2157
|
This page was automatically generated by the
LXR engine.
|