2 * usbmidi.c - ALSA USB MIDI driver
4 * Copyright (c) 2002-2009 Clemens Ladisch
7 * Based on the OSS usb-midi driver by NAGANO Daisuke,
8 * NetBSD's umidi driver by Takuya SHIOZAKI,
9 * the "USB Device Class Definition for MIDI Devices" by Roland
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
20 * Alternatively, this software may be distributed and/or modified under the
21 * terms of the GNU General Public License as published by the Free Software
22 * Foundation; either version 2 of the License, or (at your option) any later
25 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
29 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 #include <linux/kernel.h>
39 #include <linux/types.h>
40 #include <linux/bitops.h>
41 #include <linux/interrupt.h>
42 #include <linux/spinlock.h>
43 #include <linux/string.h>
44 #include <linux/init.h>
45 #include <linux/slab.h>
46 #include <linux/timer.h>
47 #include <linux/usb.h>
48 #include <linux/wait.h>
49 #include <linux/usb/audio.h>
50 #include <linux/module.h>
52 #include <sound/core.h>
53 #include <sound/control.h>
54 #include <sound/rawmidi.h>
55 #include <sound/asequencer.h>
62 * define this to log all USB packets
64 /* #define DUMP_PACKETS */
67 * how long to wait after some USB errors, so that hub_wq can disconnect() us
68 * without too many spurious errors
70 #define ERROR_DELAY_JIFFIES (HZ / 10)
76 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
77 MODULE_DESCRIPTION("USB Audio/MIDI helper module");
78 MODULE_LICENSE("Dual BSD/GPL");
81 struct usb_ms_header_descriptor
{
84 __u8 bDescriptorSubtype
;
87 } __attribute__ ((packed
));
89 struct usb_ms_endpoint_descriptor
{
92 __u8 bDescriptorSubtype
;
94 __u8 baAssocJackID
[0];
95 } __attribute__ ((packed
));
97 struct snd_usb_midi_in_endpoint
;
98 struct snd_usb_midi_out_endpoint
;
99 struct snd_usb_midi_endpoint
;
101 struct usb_protocol_ops
{
102 void (*input
)(struct snd_usb_midi_in_endpoint
*, uint8_t*, int);
103 void (*output
)(struct snd_usb_midi_out_endpoint
*ep
, struct urb
*urb
);
104 void (*output_packet
)(struct urb
*, uint8_t, uint8_t, uint8_t, uint8_t);
105 void (*init_out_endpoint
)(struct snd_usb_midi_out_endpoint
*);
106 void (*finish_out_endpoint
)(struct snd_usb_midi_out_endpoint
*);
109 struct snd_usb_midi
{
110 struct usb_device
*dev
;
111 struct snd_card
*card
;
112 struct usb_interface
*iface
;
113 const struct snd_usb_audio_quirk
*quirk
;
114 struct snd_rawmidi
*rmidi
;
115 const struct usb_protocol_ops
*usb_protocol_ops
;
116 struct list_head list
;
117 struct timer_list error_timer
;
118 spinlock_t disc_lock
;
119 struct rw_semaphore disc_rwsem
;
122 int next_midi_device
;
124 struct snd_usb_midi_endpoint
{
125 struct snd_usb_midi_out_endpoint
*out
;
126 struct snd_usb_midi_in_endpoint
*in
;
127 } endpoints
[MIDI_MAX_ENDPOINTS
];
128 unsigned long input_triggered
;
129 unsigned int opened
[2];
130 unsigned char disconnected
;
131 unsigned char input_running
;
133 struct snd_kcontrol
*roland_load_ctl
;
136 struct snd_usb_midi_out_endpoint
{
137 struct snd_usb_midi
*umidi
;
138 struct out_urb_context
{
140 struct snd_usb_midi_out_endpoint
*ep
;
142 unsigned int active_urbs
;
143 unsigned int drain_urbs
;
144 int max_transfer
; /* size of urb buffer */
145 struct tasklet_struct tasklet
;
146 unsigned int next_urb
;
147 spinlock_t buffer_lock
;
149 struct usbmidi_out_port
{
150 struct snd_usb_midi_out_endpoint
*ep
;
151 struct snd_rawmidi_substream
*substream
;
153 uint8_t cable
; /* cable number << 4 */
155 #define STATE_UNKNOWN 0
156 #define STATE_1PARAM 1
157 #define STATE_2PARAM_1 2
158 #define STATE_2PARAM_2 3
159 #define STATE_SYSEX_0 4
160 #define STATE_SYSEX_1 5
161 #define STATE_SYSEX_2 6
166 wait_queue_head_t drain_wait
;
169 struct snd_usb_midi_in_endpoint
{
170 struct snd_usb_midi
*umidi
;
171 struct urb
*urbs
[INPUT_URBS
];
172 struct usbmidi_in_port
{
173 struct snd_rawmidi_substream
*substream
;
174 u8 running_status_length
;
183 static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint
*ep
);
185 static const uint8_t snd_usbmidi_cin_length
[] = {
186 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
190 * Submits the URB, with error handling.
192 static int snd_usbmidi_submit_urb(struct urb
*urb
, gfp_t flags
)
194 int err
= usb_submit_urb(urb
, flags
);
195 if (err
< 0 && err
!= -ENODEV
)
196 dev_err(&urb
->dev
->dev
, "usb_submit_urb: %d\n", err
);
201 * Error handling for URB completion functions.
203 static int snd_usbmidi_urb_error(const struct urb
*urb
)
205 switch (urb
->status
) {
206 /* manually unlinked, or device gone */
212 /* errors that might occur during unplugging */
218 dev_err(&urb
->dev
->dev
, "urb status %d\n", urb
->status
);
219 return 0; /* continue */
224 * Receives a chunk of MIDI data.
226 static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint
*ep
,
227 int portidx
, uint8_t *data
, int length
)
229 struct usbmidi_in_port
*port
= &ep
->ports
[portidx
];
231 if (!port
->substream
) {
232 dev_dbg(&ep
->umidi
->dev
->dev
, "unexpected port %d!\n", portidx
);
235 if (!test_bit(port
->substream
->number
, &ep
->umidi
->input_triggered
))
237 snd_rawmidi_receive(port
->substream
, data
, length
);
241 static void dump_urb(const char *type
, const u8
*data
, int length
)
243 snd_printk(KERN_DEBUG
"%s packet: [", type
);
244 for (; length
> 0; ++data
, --length
)
245 printk(KERN_CONT
" %02x", *data
);
246 printk(KERN_CONT
" ]\n");
249 #define dump_urb(type, data, length) /* nothing */
253 * Processes the data read from the device.
255 static void snd_usbmidi_in_urb_complete(struct urb
*urb
)
257 struct snd_usb_midi_in_endpoint
*ep
= urb
->context
;
259 if (urb
->status
== 0) {
260 dump_urb("received", urb
->transfer_buffer
, urb
->actual_length
);
261 ep
->umidi
->usb_protocol_ops
->input(ep
, urb
->transfer_buffer
,
264 int err
= snd_usbmidi_urb_error(urb
);
266 if (err
!= -ENODEV
) {
267 ep
->error_resubmit
= 1;
268 mod_timer(&ep
->umidi
->error_timer
,
269 jiffies
+ ERROR_DELAY_JIFFIES
);
275 urb
->dev
= ep
->umidi
->dev
;
276 snd_usbmidi_submit_urb(urb
, GFP_ATOMIC
);
279 static void snd_usbmidi_out_urb_complete(struct urb
*urb
)
281 struct out_urb_context
*context
= urb
->context
;
282 struct snd_usb_midi_out_endpoint
*ep
= context
->ep
;
283 unsigned int urb_index
;
285 spin_lock(&ep
->buffer_lock
);
286 urb_index
= context
- ep
->urbs
;
287 ep
->active_urbs
&= ~(1 << urb_index
);
288 if (unlikely(ep
->drain_urbs
)) {
289 ep
->drain_urbs
&= ~(1 << urb_index
);
290 wake_up(&ep
->drain_wait
);
292 spin_unlock(&ep
->buffer_lock
);
293 if (urb
->status
< 0) {
294 int err
= snd_usbmidi_urb_error(urb
);
297 mod_timer(&ep
->umidi
->error_timer
,
298 jiffies
+ ERROR_DELAY_JIFFIES
);
302 snd_usbmidi_do_output(ep
);
306 * This is called when some data should be transferred to the device
307 * (from one or more substreams).
309 static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint
*ep
)
311 unsigned int urb_index
;
315 spin_lock_irqsave(&ep
->buffer_lock
, flags
);
316 if (ep
->umidi
->disconnected
) {
317 spin_unlock_irqrestore(&ep
->buffer_lock
, flags
);
321 urb_index
= ep
->next_urb
;
323 if (!(ep
->active_urbs
& (1 << urb_index
))) {
324 urb
= ep
->urbs
[urb_index
].urb
;
325 urb
->transfer_buffer_length
= 0;
326 ep
->umidi
->usb_protocol_ops
->output(ep
, urb
);
327 if (urb
->transfer_buffer_length
== 0)
330 dump_urb("sending", urb
->transfer_buffer
,
331 urb
->transfer_buffer_length
);
332 urb
->dev
= ep
->umidi
->dev
;
333 if (snd_usbmidi_submit_urb(urb
, GFP_ATOMIC
) < 0)
335 ep
->active_urbs
|= 1 << urb_index
;
337 if (++urb_index
>= OUTPUT_URBS
)
339 if (urb_index
== ep
->next_urb
)
342 ep
->next_urb
= urb_index
;
343 spin_unlock_irqrestore(&ep
->buffer_lock
, flags
);
346 static void snd_usbmidi_out_tasklet(unsigned long data
)
348 struct snd_usb_midi_out_endpoint
*ep
=
349 (struct snd_usb_midi_out_endpoint
*) data
;
351 snd_usbmidi_do_output(ep
);
354 /* called after transfers had been interrupted due to some USB error */
355 static void snd_usbmidi_error_timer(unsigned long data
)
357 struct snd_usb_midi
*umidi
= (struct snd_usb_midi
*)data
;
360 spin_lock(&umidi
->disc_lock
);
361 if (umidi
->disconnected
) {
362 spin_unlock(&umidi
->disc_lock
);
365 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
366 struct snd_usb_midi_in_endpoint
*in
= umidi
->endpoints
[i
].in
;
367 if (in
&& in
->error_resubmit
) {
368 in
->error_resubmit
= 0;
369 for (j
= 0; j
< INPUT_URBS
; ++j
) {
370 if (atomic_read(&in
->urbs
[j
]->use_count
))
372 in
->urbs
[j
]->dev
= umidi
->dev
;
373 snd_usbmidi_submit_urb(in
->urbs
[j
], GFP_ATOMIC
);
376 if (umidi
->endpoints
[i
].out
)
377 snd_usbmidi_do_output(umidi
->endpoints
[i
].out
);
379 spin_unlock(&umidi
->disc_lock
);
382 /* helper function to send static data that may not DMA-able */
383 static int send_bulk_static_data(struct snd_usb_midi_out_endpoint
*ep
,
384 const void *data
, int len
)
387 void *buf
= kmemdup(data
, len
, GFP_KERNEL
);
390 dump_urb("sending", buf
, len
);
392 err
= usb_bulk_msg(ep
->umidi
->dev
, ep
->urbs
[0].urb
->pipe
,
393 buf
, len
, NULL
, 250);
399 * Standard USB MIDI protocol: see the spec.
400 * Midiman protocol: like the standard protocol, but the control byte is the
401 * fourth byte in each packet, and uses length instead of CIN.
404 static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint
*ep
,
405 uint8_t *buffer
, int buffer_length
)
409 for (i
= 0; i
+ 3 < buffer_length
; i
+= 4)
410 if (buffer
[i
] != 0) {
411 int cable
= buffer
[i
] >> 4;
412 int length
= snd_usbmidi_cin_length
[buffer
[i
] & 0x0f];
413 snd_usbmidi_input_data(ep
, cable
, &buffer
[i
+ 1],
418 static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint
*ep
,
419 uint8_t *buffer
, int buffer_length
)
423 for (i
= 0; i
+ 3 < buffer_length
; i
+= 4)
424 if (buffer
[i
+ 3] != 0) {
425 int port
= buffer
[i
+ 3] >> 4;
426 int length
= buffer
[i
+ 3] & 3;
427 snd_usbmidi_input_data(ep
, port
, &buffer
[i
], length
);
432 * Buggy M-Audio device: running status on input results in a packet that has
433 * the data bytes but not the status byte and that is marked with CIN 4.
435 static void snd_usbmidi_maudio_broken_running_status_input(
436 struct snd_usb_midi_in_endpoint
*ep
,
437 uint8_t *buffer
, int buffer_length
)
441 for (i
= 0; i
+ 3 < buffer_length
; i
+= 4)
442 if (buffer
[i
] != 0) {
443 int cable
= buffer
[i
] >> 4;
444 u8 cin
= buffer
[i
] & 0x0f;
445 struct usbmidi_in_port
*port
= &ep
->ports
[cable
];
448 length
= snd_usbmidi_cin_length
[cin
];
449 if (cin
== 0xf && buffer
[i
+ 1] >= 0xf8)
450 ; /* realtime msg: no running status change */
451 else if (cin
>= 0x8 && cin
<= 0xe)
453 port
->running_status_length
= length
- 1;
454 else if (cin
== 0x4 &&
455 port
->running_status_length
!= 0 &&
456 buffer
[i
+ 1] < 0x80)
457 /* CIN 4 that is not a SysEx */
458 length
= port
->running_status_length
;
461 * All other msgs cannot begin running status.
462 * (A channel msg sent as two or three CIN 0xF
463 * packets could in theory, but this device
464 * doesn't use this format.)
466 port
->running_status_length
= 0;
467 snd_usbmidi_input_data(ep
, cable
, &buffer
[i
+ 1],
473 * QinHeng CH345 is buggy: every second packet inside a SysEx has not CIN 4
474 * but the previously seen CIN, but still with three data bytes.
476 static void ch345_broken_sysex_input(struct snd_usb_midi_in_endpoint
*ep
,
477 uint8_t *buffer
, int buffer_length
)
479 unsigned int i
, cin
, length
;
481 for (i
= 0; i
+ 3 < buffer_length
; i
+= 4) {
482 if (buffer
[i
] == 0 && i
> 0)
484 cin
= buffer
[i
] & 0x0f;
486 cin
== ep
->last_cin
&&
487 (buffer
[i
+ 1 + (cin
== 0x6)] & 0x80) == 0)
490 if (buffer
[i
+ 1] == 0x90) {
492 * Either a corrupted running status or a real note-on
493 * message; impossible to detect reliably.
497 length
= snd_usbmidi_cin_length
[cin
];
498 snd_usbmidi_input_data(ep
, 0, &buffer
[i
+ 1], length
);
499 ep
->in_sysex
= cin
== 0x4;
506 * CME protocol: like the standard protocol, but SysEx commands are sent as a
507 * single USB packet preceded by a 0x0F byte.
509 static void snd_usbmidi_cme_input(struct snd_usb_midi_in_endpoint
*ep
,
510 uint8_t *buffer
, int buffer_length
)
512 if (buffer_length
< 2 || (buffer
[0] & 0x0f) != 0x0f)
513 snd_usbmidi_standard_input(ep
, buffer
, buffer_length
);
515 snd_usbmidi_input_data(ep
, buffer
[0] >> 4,
516 &buffer
[1], buffer_length
- 1);
520 * Adds one USB MIDI packet to the output buffer.
522 static void snd_usbmidi_output_standard_packet(struct urb
*urb
, uint8_t p0
,
523 uint8_t p1
, uint8_t p2
,
528 (uint8_t *)urb
->transfer_buffer
+ urb
->transfer_buffer_length
;
533 urb
->transfer_buffer_length
+= 4;
537 * Adds one Midiman packet to the output buffer.
539 static void snd_usbmidi_output_midiman_packet(struct urb
*urb
, uint8_t p0
,
540 uint8_t p1
, uint8_t p2
,
545 (uint8_t *)urb
->transfer_buffer
+ urb
->transfer_buffer_length
;
549 buf
[3] = (p0
& 0xf0) | snd_usbmidi_cin_length
[p0
& 0x0f];
550 urb
->transfer_buffer_length
+= 4;
554 * Converts MIDI commands to USB MIDI packets.
556 static void snd_usbmidi_transmit_byte(struct usbmidi_out_port
*port
,
557 uint8_t b
, struct urb
*urb
)
559 uint8_t p0
= port
->cable
;
560 void (*output_packet
)(struct urb
*, uint8_t, uint8_t, uint8_t, uint8_t) =
561 port
->ep
->umidi
->usb_protocol_ops
->output_packet
;
564 output_packet(urb
, p0
| 0x0f, b
, 0, 0);
565 } else if (b
>= 0xf0) {
569 port
->state
= STATE_SYSEX_1
;
574 port
->state
= STATE_1PARAM
;
578 port
->state
= STATE_2PARAM_1
;
582 port
->state
= STATE_UNKNOWN
;
585 output_packet(urb
, p0
| 0x05, 0xf6, 0, 0);
586 port
->state
= STATE_UNKNOWN
;
589 switch (port
->state
) {
591 output_packet(urb
, p0
| 0x05, 0xf7, 0, 0);
594 output_packet(urb
, p0
| 0x06, port
->data
[0],
598 output_packet(urb
, p0
| 0x07, port
->data
[0],
599 port
->data
[1], 0xf7);
602 port
->state
= STATE_UNKNOWN
;
605 } else if (b
>= 0x80) {
607 if (b
>= 0xc0 && b
<= 0xdf)
608 port
->state
= STATE_1PARAM
;
610 port
->state
= STATE_2PARAM_1
;
611 } else { /* b < 0x80 */
612 switch (port
->state
) {
614 if (port
->data
[0] < 0xf0) {
615 p0
|= port
->data
[0] >> 4;
618 port
->state
= STATE_UNKNOWN
;
620 output_packet(urb
, p0
, port
->data
[0], b
, 0);
624 port
->state
= STATE_2PARAM_2
;
627 if (port
->data
[0] < 0xf0) {
628 p0
|= port
->data
[0] >> 4;
629 port
->state
= STATE_2PARAM_1
;
632 port
->state
= STATE_UNKNOWN
;
634 output_packet(urb
, p0
, port
->data
[0], port
->data
[1], b
);
638 port
->state
= STATE_SYSEX_1
;
642 port
->state
= STATE_SYSEX_2
;
645 output_packet(urb
, p0
| 0x04, port
->data
[0],
647 port
->state
= STATE_SYSEX_0
;
653 static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint
*ep
,
658 /* FIXME: lower-numbered ports can starve higher-numbered ports */
659 for (p
= 0; p
< 0x10; ++p
) {
660 struct usbmidi_out_port
*port
= &ep
->ports
[p
];
663 while (urb
->transfer_buffer_length
+ 3 < ep
->max_transfer
) {
665 if (snd_rawmidi_transmit(port
->substream
, &b
, 1) != 1) {
669 snd_usbmidi_transmit_byte(port
, b
, urb
);
674 static const struct usb_protocol_ops snd_usbmidi_standard_ops
= {
675 .input
= snd_usbmidi_standard_input
,
676 .output
= snd_usbmidi_standard_output
,
677 .output_packet
= snd_usbmidi_output_standard_packet
,
680 static const struct usb_protocol_ops snd_usbmidi_midiman_ops
= {
681 .input
= snd_usbmidi_midiman_input
,
682 .output
= snd_usbmidi_standard_output
,
683 .output_packet
= snd_usbmidi_output_midiman_packet
,
687 struct usb_protocol_ops snd_usbmidi_maudio_broken_running_status_ops
= {
688 .input
= snd_usbmidi_maudio_broken_running_status_input
,
689 .output
= snd_usbmidi_standard_output
,
690 .output_packet
= snd_usbmidi_output_standard_packet
,
693 static const struct usb_protocol_ops snd_usbmidi_cme_ops
= {
694 .input
= snd_usbmidi_cme_input
,
695 .output
= snd_usbmidi_standard_output
,
696 .output_packet
= snd_usbmidi_output_standard_packet
,
699 static const struct usb_protocol_ops snd_usbmidi_ch345_broken_sysex_ops
= {
700 .input
= ch345_broken_sysex_input
,
701 .output
= snd_usbmidi_standard_output
,
702 .output_packet
= snd_usbmidi_output_standard_packet
,
706 * AKAI MPD16 protocol:
708 * For control port (endpoint 1):
709 * ==============================
710 * One or more chunks consisting of first byte of (0x10 | msg_len) and then a
711 * SysEx message (msg_len=9 bytes long).
713 * For data port (endpoint 2):
714 * ===========================
715 * One or more chunks consisting of first byte of (0x20 | msg_len) and then a
716 * MIDI message (msg_len bytes long)
718 * Messages sent: Active Sense, Note On, Poly Pressure, Control Change.
720 static void snd_usbmidi_akai_input(struct snd_usb_midi_in_endpoint
*ep
,
721 uint8_t *buffer
, int buffer_length
)
723 unsigned int pos
= 0;
724 unsigned int len
= (unsigned int)buffer_length
;
726 unsigned int port
= (buffer
[pos
] >> 4) - 1;
727 unsigned int msg_len
= buffer
[pos
] & 0x0f;
729 if (pos
+ msg_len
<= len
&& port
< 2)
730 snd_usbmidi_input_data(ep
, 0, &buffer
[pos
], msg_len
);
735 #define MAX_AKAI_SYSEX_LEN 9
737 static void snd_usbmidi_akai_output(struct snd_usb_midi_out_endpoint
*ep
,
741 int pos
, end
, count
, buf_end
;
742 uint8_t tmp
[MAX_AKAI_SYSEX_LEN
];
743 struct snd_rawmidi_substream
*substream
= ep
->ports
[0].substream
;
745 if (!ep
->ports
[0].active
)
748 msg
= urb
->transfer_buffer
+ urb
->transfer_buffer_length
;
749 buf_end
= ep
->max_transfer
- MAX_AKAI_SYSEX_LEN
- 1;
751 /* only try adding more data when there's space for at least 1 SysEx */
752 while (urb
->transfer_buffer_length
< buf_end
) {
753 count
= snd_rawmidi_transmit_peek(substream
,
754 tmp
, MAX_AKAI_SYSEX_LEN
);
756 ep
->ports
[0].active
= 0;
759 /* try to skip non-SysEx data */
760 for (pos
= 0; pos
< count
&& tmp
[pos
] != 0xF0; pos
++)
764 snd_rawmidi_transmit_ack(substream
, pos
);
768 /* look for the start or end marker */
769 for (end
= 1; end
< count
&& tmp
[end
] < 0xF0; end
++)
772 /* next SysEx started before the end of current one */
773 if (end
< count
&& tmp
[end
] == 0xF0) {
774 /* it's incomplete - drop it */
775 snd_rawmidi_transmit_ack(substream
, end
);
779 if (end
< count
&& tmp
[end
] == 0xF7) {
780 /* queue it, ack it, and get the next one */
782 msg
[0] = 0x10 | count
;
783 memcpy(&msg
[1], tmp
, count
);
784 snd_rawmidi_transmit_ack(substream
, count
);
785 urb
->transfer_buffer_length
+= count
+ 1;
789 /* less than 9 bytes and no end byte - wait for more */
790 if (count
< MAX_AKAI_SYSEX_LEN
) {
791 ep
->ports
[0].active
= 0;
794 /* 9 bytes and no end marker in sight - malformed, skip it */
795 snd_rawmidi_transmit_ack(substream
, count
);
799 static const struct usb_protocol_ops snd_usbmidi_akai_ops
= {
800 .input
= snd_usbmidi_akai_input
,
801 .output
= snd_usbmidi_akai_output
,
805 * Novation USB MIDI protocol: number of data bytes is in the first byte
806 * (when receiving) (+1!) or in the second byte (when sending); data begins
810 static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint
*ep
,
811 uint8_t *buffer
, int buffer_length
)
813 if (buffer_length
< 2 || !buffer
[0] || buffer_length
< buffer
[0] + 1)
815 snd_usbmidi_input_data(ep
, 0, &buffer
[2], buffer
[0] - 1);
818 static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint
*ep
,
821 uint8_t *transfer_buffer
;
824 if (!ep
->ports
[0].active
)
826 transfer_buffer
= urb
->transfer_buffer
;
827 count
= snd_rawmidi_transmit(ep
->ports
[0].substream
,
829 ep
->max_transfer
- 2);
831 ep
->ports
[0].active
= 0;
834 transfer_buffer
[0] = 0;
835 transfer_buffer
[1] = count
;
836 urb
->transfer_buffer_length
= 2 + count
;
839 static const struct usb_protocol_ops snd_usbmidi_novation_ops
= {
840 .input
= snd_usbmidi_novation_input
,
841 .output
= snd_usbmidi_novation_output
,
845 * "raw" protocol: just move raw MIDI bytes from/to the endpoint
848 static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint
*ep
,
849 uint8_t *buffer
, int buffer_length
)
851 snd_usbmidi_input_data(ep
, 0, buffer
, buffer_length
);
854 static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint
*ep
,
859 if (!ep
->ports
[0].active
)
861 count
= snd_rawmidi_transmit(ep
->ports
[0].substream
,
862 urb
->transfer_buffer
,
865 ep
->ports
[0].active
= 0;
868 urb
->transfer_buffer_length
= count
;
871 static const struct usb_protocol_ops snd_usbmidi_raw_ops
= {
872 .input
= snd_usbmidi_raw_input
,
873 .output
= snd_usbmidi_raw_output
,
877 * FTDI protocol: raw MIDI bytes, but input packets have two modem status bytes.
880 static void snd_usbmidi_ftdi_input(struct snd_usb_midi_in_endpoint
*ep
,
881 uint8_t *buffer
, int buffer_length
)
883 if (buffer_length
> 2)
884 snd_usbmidi_input_data(ep
, 0, buffer
+ 2, buffer_length
- 2);
887 static const struct usb_protocol_ops snd_usbmidi_ftdi_ops
= {
888 .input
= snd_usbmidi_ftdi_input
,
889 .output
= snd_usbmidi_raw_output
,
892 static void snd_usbmidi_us122l_input(struct snd_usb_midi_in_endpoint
*ep
,
893 uint8_t *buffer
, int buffer_length
)
895 if (buffer_length
!= 9)
898 while (buffer_length
&& buffer
[buffer_length
- 1] == 0xFD)
901 snd_usbmidi_input_data(ep
, 0, buffer
, buffer_length
);
904 static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint
*ep
,
909 if (!ep
->ports
[0].active
)
911 switch (snd_usb_get_speed(ep
->umidi
->dev
)) {
913 case USB_SPEED_SUPER
:
914 case USB_SPEED_SUPER_PLUS
:
920 count
= snd_rawmidi_transmit(ep
->ports
[0].substream
,
921 urb
->transfer_buffer
,
924 ep
->ports
[0].active
= 0;
928 memset(urb
->transfer_buffer
+ count
, 0xFD, ep
->max_transfer
- count
);
929 urb
->transfer_buffer_length
= ep
->max_transfer
;
932 static const struct usb_protocol_ops snd_usbmidi_122l_ops
= {
933 .input
= snd_usbmidi_us122l_input
,
934 .output
= snd_usbmidi_us122l_output
,
938 * Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching.
941 static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint
*ep
)
943 static const u8 init_data
[] = {
944 /* initialization magic: "get version" */
946 0x00, 0x20, 0x31, /* Emagic */
948 0x0b, /* version number request */
949 0x00, /* command version */
950 0x00, /* EEPROM, box 0 */
953 send_bulk_static_data(ep
, init_data
, sizeof(init_data
));
954 /* while we're at it, pour on more magic */
955 send_bulk_static_data(ep
, init_data
, sizeof(init_data
));
958 static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint
*ep
)
960 static const u8 finish_data
[] = {
961 /* switch to patch mode with last preset */
963 0x00, 0x20, 0x31, /* Emagic */
965 0x10, /* patch switch command */
966 0x00, /* command version */
967 0x7f, /* to all boxes */
968 0x40, /* last preset in EEPROM */
971 send_bulk_static_data(ep
, finish_data
, sizeof(finish_data
));
974 static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint
*ep
,
975 uint8_t *buffer
, int buffer_length
)
979 /* FF indicates end of valid data */
980 for (i
= 0; i
< buffer_length
; ++i
)
981 if (buffer
[i
] == 0xff) {
986 /* handle F5 at end of last buffer */
990 while (buffer_length
> 0) {
991 /* determine size of data until next F5 */
992 for (i
= 0; i
< buffer_length
; ++i
)
993 if (buffer
[i
] == 0xf5)
995 snd_usbmidi_input_data(ep
, ep
->current_port
, buffer
, i
);
999 if (buffer_length
<= 0)
1001 /* assert(buffer[0] == 0xf5); */
1007 if (buffer_length
<= 0)
1009 if (buffer
[0] < 0x80) {
1010 ep
->current_port
= (buffer
[0] - 1) & 15;
1018 static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint
*ep
,
1021 int port0
= ep
->current_port
;
1022 uint8_t *buf
= urb
->transfer_buffer
;
1023 int buf_free
= ep
->max_transfer
;
1026 for (i
= 0; i
< 0x10; ++i
) {
1027 /* round-robin, starting at the last current port */
1028 int portnum
= (port0
+ i
) & 15;
1029 struct usbmidi_out_port
*port
= &ep
->ports
[portnum
];
1033 if (snd_rawmidi_transmit_peek(port
->substream
, buf
, 1) != 1) {
1038 if (portnum
!= ep
->current_port
) {
1041 ep
->current_port
= portnum
;
1043 buf
[1] = (portnum
+ 1) & 15;
1050 length
= snd_rawmidi_transmit(port
->substream
, buf
, buf_free
);
1058 if (buf_free
< ep
->max_transfer
&& buf_free
> 0) {
1062 urb
->transfer_buffer_length
= ep
->max_transfer
- buf_free
;
1065 static const struct usb_protocol_ops snd_usbmidi_emagic_ops
= {
1066 .input
= snd_usbmidi_emagic_input
,
1067 .output
= snd_usbmidi_emagic_output
,
1068 .init_out_endpoint
= snd_usbmidi_emagic_init_out
,
1069 .finish_out_endpoint
= snd_usbmidi_emagic_finish_out
,
1073 static void update_roland_altsetting(struct snd_usb_midi
*umidi
)
1075 struct usb_interface
*intf
;
1076 struct usb_host_interface
*hostif
;
1077 struct usb_interface_descriptor
*intfd
;
1080 intf
= umidi
->iface
;
1081 is_light_load
= intf
->cur_altsetting
!= intf
->altsetting
;
1082 if (umidi
->roland_load_ctl
->private_value
== is_light_load
)
1084 hostif
= &intf
->altsetting
[umidi
->roland_load_ctl
->private_value
];
1085 intfd
= get_iface_desc(hostif
);
1086 snd_usbmidi_input_stop(&umidi
->list
);
1087 usb_set_interface(umidi
->dev
, intfd
->bInterfaceNumber
,
1088 intfd
->bAlternateSetting
);
1089 snd_usbmidi_input_start(&umidi
->list
);
1092 static int substream_open(struct snd_rawmidi_substream
*substream
, int dir
,
1095 struct snd_usb_midi
*umidi
= substream
->rmidi
->private_data
;
1096 struct snd_kcontrol
*ctl
;
1098 down_read(&umidi
->disc_rwsem
);
1099 if (umidi
->disconnected
) {
1100 up_read(&umidi
->disc_rwsem
);
1101 return open
? -ENODEV
: 0;
1104 mutex_lock(&umidi
->mutex
);
1106 if (!umidi
->opened
[0] && !umidi
->opened
[1]) {
1107 if (umidi
->roland_load_ctl
) {
1108 ctl
= umidi
->roland_load_ctl
;
1109 ctl
->vd
[0].access
|=
1110 SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
1111 snd_ctl_notify(umidi
->card
,
1112 SNDRV_CTL_EVENT_MASK_INFO
, &ctl
->id
);
1113 update_roland_altsetting(umidi
);
1116 umidi
->opened
[dir
]++;
1117 if (umidi
->opened
[1])
1118 snd_usbmidi_input_start(&umidi
->list
);
1120 umidi
->opened
[dir
]--;
1121 if (!umidi
->opened
[1])
1122 snd_usbmidi_input_stop(&umidi
->list
);
1123 if (!umidi
->opened
[0] && !umidi
->opened
[1]) {
1124 if (umidi
->roland_load_ctl
) {
1125 ctl
= umidi
->roland_load_ctl
;
1126 ctl
->vd
[0].access
&=
1127 ~SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
1128 snd_ctl_notify(umidi
->card
,
1129 SNDRV_CTL_EVENT_MASK_INFO
, &ctl
->id
);
1133 mutex_unlock(&umidi
->mutex
);
1134 up_read(&umidi
->disc_rwsem
);
1138 static int snd_usbmidi_output_open(struct snd_rawmidi_substream
*substream
)
1140 struct snd_usb_midi
*umidi
= substream
->rmidi
->private_data
;
1141 struct usbmidi_out_port
*port
= NULL
;
1144 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
)
1145 if (umidi
->endpoints
[i
].out
)
1146 for (j
= 0; j
< 0x10; ++j
)
1147 if (umidi
->endpoints
[i
].out
->ports
[j
].substream
== substream
) {
1148 port
= &umidi
->endpoints
[i
].out
->ports
[j
];
1156 substream
->runtime
->private_data
= port
;
1157 port
->state
= STATE_UNKNOWN
;
1158 return substream_open(substream
, 0, 1);
1161 static int snd_usbmidi_output_close(struct snd_rawmidi_substream
*substream
)
1163 return substream_open(substream
, 0, 0);
1166 static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream
*substream
,
1169 struct usbmidi_out_port
*port
=
1170 (struct usbmidi_out_port
*)substream
->runtime
->private_data
;
1174 if (port
->ep
->umidi
->disconnected
) {
1175 /* gobble up remaining bytes to prevent wait in
1176 * snd_rawmidi_drain_output */
1177 while (!snd_rawmidi_transmit_empty(substream
))
1178 snd_rawmidi_transmit_ack(substream
, 1);
1181 tasklet_schedule(&port
->ep
->tasklet
);
1185 static void snd_usbmidi_output_drain(struct snd_rawmidi_substream
*substream
)
1187 struct usbmidi_out_port
*port
= substream
->runtime
->private_data
;
1188 struct snd_usb_midi_out_endpoint
*ep
= port
->ep
;
1189 unsigned int drain_urbs
;
1191 long timeout
= msecs_to_jiffies(50);
1193 if (ep
->umidi
->disconnected
)
1196 * The substream buffer is empty, but some data might still be in the
1197 * currently active URBs, so we have to wait for those to complete.
1199 spin_lock_irq(&ep
->buffer_lock
);
1200 drain_urbs
= ep
->active_urbs
;
1202 ep
->drain_urbs
|= drain_urbs
;
1204 prepare_to_wait(&ep
->drain_wait
, &wait
,
1205 TASK_UNINTERRUPTIBLE
);
1206 spin_unlock_irq(&ep
->buffer_lock
);
1207 timeout
= schedule_timeout(timeout
);
1208 spin_lock_irq(&ep
->buffer_lock
);
1209 drain_urbs
&= ep
->drain_urbs
;
1210 } while (drain_urbs
&& timeout
);
1211 finish_wait(&ep
->drain_wait
, &wait
);
1213 spin_unlock_irq(&ep
->buffer_lock
);
1216 static int snd_usbmidi_input_open(struct snd_rawmidi_substream
*substream
)
1218 return substream_open(substream
, 1, 1);
1221 static int snd_usbmidi_input_close(struct snd_rawmidi_substream
*substream
)
1223 return substream_open(substream
, 1, 0);
1226 static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream
*substream
,
1229 struct snd_usb_midi
*umidi
= substream
->rmidi
->private_data
;
1232 set_bit(substream
->number
, &umidi
->input_triggered
);
1234 clear_bit(substream
->number
, &umidi
->input_triggered
);
1237 static const struct snd_rawmidi_ops snd_usbmidi_output_ops
= {
1238 .open
= snd_usbmidi_output_open
,
1239 .close
= snd_usbmidi_output_close
,
1240 .trigger
= snd_usbmidi_output_trigger
,
1241 .drain
= snd_usbmidi_output_drain
,
1244 static const struct snd_rawmidi_ops snd_usbmidi_input_ops
= {
1245 .open
= snd_usbmidi_input_open
,
1246 .close
= snd_usbmidi_input_close
,
1247 .trigger
= snd_usbmidi_input_trigger
1250 static void free_urb_and_buffer(struct snd_usb_midi
*umidi
, struct urb
*urb
,
1251 unsigned int buffer_length
)
1253 usb_free_coherent(umidi
->dev
, buffer_length
,
1254 urb
->transfer_buffer
, urb
->transfer_dma
);
1259 * Frees an input endpoint.
1260 * May be called when ep hasn't been initialized completely.
1262 static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint
*ep
)
1266 for (i
= 0; i
< INPUT_URBS
; ++i
)
1268 free_urb_and_buffer(ep
->umidi
, ep
->urbs
[i
],
1269 ep
->urbs
[i
]->transfer_buffer_length
);
1274 * Creates an input endpoint.
1276 static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi
*umidi
,
1277 struct snd_usb_midi_endpoint_info
*ep_info
,
1278 struct snd_usb_midi_endpoint
*rep
)
1280 struct snd_usb_midi_in_endpoint
*ep
;
1287 ep
= kzalloc(sizeof(*ep
), GFP_KERNEL
);
1292 for (i
= 0; i
< INPUT_URBS
; ++i
) {
1293 ep
->urbs
[i
] = usb_alloc_urb(0, GFP_KERNEL
);
1295 snd_usbmidi_in_endpoint_delete(ep
);
1299 if (ep_info
->in_interval
)
1300 pipe
= usb_rcvintpipe(umidi
->dev
, ep_info
->in_ep
);
1302 pipe
= usb_rcvbulkpipe(umidi
->dev
, ep_info
->in_ep
);
1303 length
= usb_maxpacket(umidi
->dev
, pipe
, 0);
1304 for (i
= 0; i
< INPUT_URBS
; ++i
) {
1305 buffer
= usb_alloc_coherent(umidi
->dev
, length
, GFP_KERNEL
,
1306 &ep
->urbs
[i
]->transfer_dma
);
1308 snd_usbmidi_in_endpoint_delete(ep
);
1311 if (ep_info
->in_interval
)
1312 usb_fill_int_urb(ep
->urbs
[i
], umidi
->dev
,
1313 pipe
, buffer
, length
,
1314 snd_usbmidi_in_urb_complete
,
1315 ep
, ep_info
->in_interval
);
1317 usb_fill_bulk_urb(ep
->urbs
[i
], umidi
->dev
,
1318 pipe
, buffer
, length
,
1319 snd_usbmidi_in_urb_complete
, ep
);
1320 ep
->urbs
[i
]->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
1328 * Frees an output endpoint.
1329 * May be called when ep hasn't been initialized completely.
1331 static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint
*ep
)
1335 for (i
= 0; i
< OUTPUT_URBS
; ++i
)
1336 if (ep
->urbs
[i
].urb
) {
1337 free_urb_and_buffer(ep
->umidi
, ep
->urbs
[i
].urb
,
1339 ep
->urbs
[i
].urb
= NULL
;
1343 static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint
*ep
)
1345 snd_usbmidi_out_endpoint_clear(ep
);
1350 * Creates an output endpoint, and initializes output ports.
1352 static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi
*umidi
,
1353 struct snd_usb_midi_endpoint_info
*ep_info
,
1354 struct snd_usb_midi_endpoint
*rep
)
1356 struct snd_usb_midi_out_endpoint
*ep
;
1362 ep
= kzalloc(sizeof(*ep
), GFP_KERNEL
);
1367 for (i
= 0; i
< OUTPUT_URBS
; ++i
) {
1368 ep
->urbs
[i
].urb
= usb_alloc_urb(0, GFP_KERNEL
);
1369 if (!ep
->urbs
[i
].urb
) {
1370 snd_usbmidi_out_endpoint_delete(ep
);
1373 ep
->urbs
[i
].ep
= ep
;
1375 if (ep_info
->out_interval
)
1376 pipe
= usb_sndintpipe(umidi
->dev
, ep_info
->out_ep
);
1378 pipe
= usb_sndbulkpipe(umidi
->dev
, ep_info
->out_ep
);
1379 switch (umidi
->usb_id
) {
1381 ep
->max_transfer
= usb_maxpacket(umidi
->dev
, pipe
, 1);
1384 * Various chips declare a packet size larger than 4 bytes, but
1385 * do not actually work with larger packets:
1387 case USB_ID(0x0a67, 0x5011): /* Medeli DD305 */
1388 case USB_ID(0x0a92, 0x1020): /* ESI M4U */
1389 case USB_ID(0x1430, 0x474b): /* RedOctane GH MIDI INTERFACE */
1390 case USB_ID(0x15ca, 0x0101): /* Textech USB Midi Cable */
1391 case USB_ID(0x15ca, 0x1806): /* Textech USB Midi Cable */
1392 case USB_ID(0x1a86, 0x752d): /* QinHeng CH345 "USB2.0-MIDI" */
1393 case USB_ID(0xfc08, 0x0101): /* Unknown vendor Cable */
1394 ep
->max_transfer
= 4;
1397 * Some devices only work with 9 bytes packet size:
1399 case USB_ID(0x0644, 0x800E): /* Tascam US-122L */
1400 case USB_ID(0x0644, 0x800F): /* Tascam US-144 */
1401 ep
->max_transfer
= 9;
1404 for (i
= 0; i
< OUTPUT_URBS
; ++i
) {
1405 buffer
= usb_alloc_coherent(umidi
->dev
,
1406 ep
->max_transfer
, GFP_KERNEL
,
1407 &ep
->urbs
[i
].urb
->transfer_dma
);
1409 snd_usbmidi_out_endpoint_delete(ep
);
1412 if (ep_info
->out_interval
)
1413 usb_fill_int_urb(ep
->urbs
[i
].urb
, umidi
->dev
,
1414 pipe
, buffer
, ep
->max_transfer
,
1415 snd_usbmidi_out_urb_complete
,
1416 &ep
->urbs
[i
], ep_info
->out_interval
);
1418 usb_fill_bulk_urb(ep
->urbs
[i
].urb
, umidi
->dev
,
1419 pipe
, buffer
, ep
->max_transfer
,
1420 snd_usbmidi_out_urb_complete
,
1422 ep
->urbs
[i
].urb
->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
1425 spin_lock_init(&ep
->buffer_lock
);
1426 tasklet_init(&ep
->tasklet
, snd_usbmidi_out_tasklet
, (unsigned long)ep
);
1427 init_waitqueue_head(&ep
->drain_wait
);
1429 for (i
= 0; i
< 0x10; ++i
)
1430 if (ep_info
->out_cables
& (1 << i
)) {
1431 ep
->ports
[i
].ep
= ep
;
1432 ep
->ports
[i
].cable
= i
<< 4;
1435 if (umidi
->usb_protocol_ops
->init_out_endpoint
)
1436 umidi
->usb_protocol_ops
->init_out_endpoint(ep
);
1445 static void snd_usbmidi_free(struct snd_usb_midi
*umidi
)
1449 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
1450 struct snd_usb_midi_endpoint
*ep
= &umidi
->endpoints
[i
];
1452 snd_usbmidi_out_endpoint_delete(ep
->out
);
1454 snd_usbmidi_in_endpoint_delete(ep
->in
);
1456 mutex_destroy(&umidi
->mutex
);
1461 * Unlinks all URBs (must be done before the usb_device is deleted).
1463 void snd_usbmidi_disconnect(struct list_head
*p
)
1465 struct snd_usb_midi
*umidi
;
1468 umidi
= list_entry(p
, struct snd_usb_midi
, list
);
1470 * an URB's completion handler may start the timer and
1471 * a timer may submit an URB. To reliably break the cycle
1472 * a flag under lock must be used
1474 down_write(&umidi
->disc_rwsem
);
1475 spin_lock_irq(&umidi
->disc_lock
);
1476 umidi
->disconnected
= 1;
1477 spin_unlock_irq(&umidi
->disc_lock
);
1478 up_write(&umidi
->disc_rwsem
);
1480 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
1481 struct snd_usb_midi_endpoint
*ep
= &umidi
->endpoints
[i
];
1483 tasklet_kill(&ep
->out
->tasklet
);
1485 for (j
= 0; j
< OUTPUT_URBS
; ++j
)
1486 usb_kill_urb(ep
->out
->urbs
[j
].urb
);
1487 if (umidi
->usb_protocol_ops
->finish_out_endpoint
)
1488 umidi
->usb_protocol_ops
->finish_out_endpoint(ep
->out
);
1489 ep
->out
->active_urbs
= 0;
1490 if (ep
->out
->drain_urbs
) {
1491 ep
->out
->drain_urbs
= 0;
1492 wake_up(&ep
->out
->drain_wait
);
1496 for (j
= 0; j
< INPUT_URBS
; ++j
)
1497 usb_kill_urb(ep
->in
->urbs
[j
]);
1498 /* free endpoints here; later call can result in Oops */
1500 snd_usbmidi_out_endpoint_clear(ep
->out
);
1502 snd_usbmidi_in_endpoint_delete(ep
->in
);
1506 del_timer_sync(&umidi
->error_timer
);
1508 EXPORT_SYMBOL(snd_usbmidi_disconnect
);
1510 static void snd_usbmidi_rawmidi_free(struct snd_rawmidi
*rmidi
)
1512 struct snd_usb_midi
*umidi
= rmidi
->private_data
;
1513 snd_usbmidi_free(umidi
);
1516 static struct snd_rawmidi_substream
*snd_usbmidi_find_substream(struct snd_usb_midi
*umidi
,
1520 struct snd_rawmidi_substream
*substream
;
1522 list_for_each_entry(substream
, &umidi
->rmidi
->streams
[stream
].substreams
,
1524 if (substream
->number
== number
)
1531 * This list specifies names for ports that do not fit into the standard
1532 * "(product) MIDI (n)" schema because they aren't external MIDI ports,
1533 * such as internal control or synthesizer ports.
1535 static struct port_info
{
1540 unsigned int seq_flags
;
1541 } snd_usbmidi_port_info
[] = {
1542 #define PORT_INFO(vendor, product, num, name_, voices_, flags) \
1543 { .id = USB_ID(vendor, product), \
1544 .port = num, .voices = voices_, \
1545 .name = name_, .seq_flags = flags }
1546 #define EXTERNAL_PORT(vendor, product, num, name) \
1547 PORT_INFO(vendor, product, num, name, 0, \
1548 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1549 SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1550 SNDRV_SEQ_PORT_TYPE_PORT)
1551 #define CONTROL_PORT(vendor, product, num, name) \
1552 PORT_INFO(vendor, product, num, name, 0, \
1553 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1554 SNDRV_SEQ_PORT_TYPE_HARDWARE)
1555 #define GM_SYNTH_PORT(vendor, product, num, name, voices) \
1556 PORT_INFO(vendor, product, num, name, voices, \
1557 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1558 SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
1559 SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1560 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
1561 #define ROLAND_SYNTH_PORT(vendor, product, num, name, voices) \
1562 PORT_INFO(vendor, product, num, name, voices, \
1563 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1564 SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
1565 SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \
1566 SNDRV_SEQ_PORT_TYPE_MIDI_GS | \
1567 SNDRV_SEQ_PORT_TYPE_MIDI_XG | \
1568 SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1569 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
1570 #define SOUNDCANVAS_PORT(vendor, product, num, name, voices) \
1571 PORT_INFO(vendor, product, num, name, voices, \
1572 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1573 SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
1574 SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \
1575 SNDRV_SEQ_PORT_TYPE_MIDI_GS | \
1576 SNDRV_SEQ_PORT_TYPE_MIDI_XG | \
1577 SNDRV_SEQ_PORT_TYPE_MIDI_MT32 | \
1578 SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1579 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
1580 /* Yamaha MOTIF XF */
1581 GM_SYNTH_PORT(0x0499, 0x105c, 0, "%s Tone Generator", 128),
1582 CONTROL_PORT(0x0499, 0x105c, 1, "%s Remote Control"),
1583 EXTERNAL_PORT(0x0499, 0x105c, 2, "%s Thru"),
1584 CONTROL_PORT(0x0499, 0x105c, 3, "%s Editor"),
1586 CONTROL_PORT(0x0582, 0x0000, 2, "%s Control"),
1587 /* Roland SC-8850 */
1588 SOUNDCANVAS_PORT(0x0582, 0x0003, 0, "%s Part A", 128),
1589 SOUNDCANVAS_PORT(0x0582, 0x0003, 1, "%s Part B", 128),
1590 SOUNDCANVAS_PORT(0x0582, 0x0003, 2, "%s Part C", 128),
1591 SOUNDCANVAS_PORT(0x0582, 0x0003, 3, "%s Part D", 128),
1592 EXTERNAL_PORT(0x0582, 0x0003, 4, "%s MIDI 1"),
1593 EXTERNAL_PORT(0x0582, 0x0003, 5, "%s MIDI 2"),
1595 EXTERNAL_PORT(0x0582, 0x0004, 0, "%s MIDI"),
1596 CONTROL_PORT(0x0582, 0x0004, 1, "%s Control"),
1597 /* Roland SC-8820 */
1598 SOUNDCANVAS_PORT(0x0582, 0x0007, 0, "%s Part A", 64),
1599 SOUNDCANVAS_PORT(0x0582, 0x0007, 1, "%s Part B", 64),
1600 EXTERNAL_PORT(0x0582, 0x0007, 2, "%s MIDI"),
1602 SOUNDCANVAS_PORT(0x0582, 0x000b, 0, "%s Part A", 64),
1603 SOUNDCANVAS_PORT(0x0582, 0x000b, 1, "%s Part B", 64),
1604 EXTERNAL_PORT(0x0582, 0x000b, 2, "%s MIDI"),
1606 SOUNDCANVAS_PORT(0x0582, 0x000c, 0, "%s Part A", 64),
1607 SOUNDCANVAS_PORT(0x0582, 0x000c, 1, "%s Part B", 64),
1608 EXTERNAL_PORT(0x0582, 0x000c, 2, "%s MIDI"),
1610 CONTROL_PORT(0x0582, 0x0014, 8, "%s Control"),
1612 ROLAND_SYNTH_PORT(0x0582, 0x0016, 0, "%s Part A", 128),
1613 ROLAND_SYNTH_PORT(0x0582, 0x0016, 1, "%s Part B", 128),
1614 EXTERNAL_PORT(0x0582, 0x0016, 2, "%s MIDI 1"),
1615 EXTERNAL_PORT(0x0582, 0x0016, 3, "%s MIDI 2"),
1617 CONTROL_PORT(0x0582, 0x0023, 5, "%s Control"),
1619 ROLAND_SYNTH_PORT(0x0582, 0x0027, 0, "%s Part A", 64),
1620 ROLAND_SYNTH_PORT(0x0582, 0x0027, 1, "%s Part B", 64),
1621 EXTERNAL_PORT(0x0582, 0x0027, 2, "%s MIDI"),
1623 ROLAND_SYNTH_PORT(0x0582, 0x0029, 0, "%s Part A", 128),
1624 ROLAND_SYNTH_PORT(0x0582, 0x0029, 1, "%s Part B", 128),
1625 EXTERNAL_PORT(0x0582, 0x0029, 2, "%s MIDI 1"),
1626 EXTERNAL_PORT(0x0582, 0x0029, 3, "%s MIDI 2"),
1628 EXTERNAL_PORT(0x0582, 0x002b, 0, "%s MIDI"),
1629 CONTROL_PORT(0x0582, 0x002b, 1, "%s Control"),
1631 EXTERNAL_PORT(0x0582, 0x002f, 0, "%s MIDI"),
1632 EXTERNAL_PORT(0x0582, 0x002f, 1, "%s External MIDI"),
1633 EXTERNAL_PORT(0x0582, 0x002f, 2, "%s Sync"),
1635 EXTERNAL_PORT(0x0582, 0x0033, 0, "%s MIDI"),
1636 EXTERNAL_PORT(0x0582, 0x0033, 1, "%s 1"),
1637 EXTERNAL_PORT(0x0582, 0x0033, 2, "%s 2"),
1639 EXTERNAL_PORT(0x0582, 0x003b, 0, "%s MIDI"),
1640 CONTROL_PORT(0x0582, 0x003b, 1, "%s Control"),
1641 /* Edirol UA-1000 */
1642 EXTERNAL_PORT(0x0582, 0x0044, 0, "%s MIDI"),
1643 CONTROL_PORT(0x0582, 0x0044, 1, "%s Control"),
1645 EXTERNAL_PORT(0x0582, 0x0048, 0, "%s MIDI"),
1646 EXTERNAL_PORT(0x0582, 0x0048, 1, "%s 1"),
1647 EXTERNAL_PORT(0x0582, 0x0048, 2, "%s 2"),
1649 EXTERNAL_PORT(0x0582, 0x004d, 0, "%s MIDI"),
1650 EXTERNAL_PORT(0x0582, 0x004d, 1, "%s 1"),
1651 EXTERNAL_PORT(0x0582, 0x004d, 2, "%s 2"),
1653 CONTROL_PORT(0x0582, 0x0089, 0, "%s Control"),
1655 CONTROL_PORT(0x0582, 0x009a, 3, "%s Control"),
1657 CONTROL_PORT(0x0582, 0x00b2, 0, "%s Control"),
1658 EXTERNAL_PORT(0x0582, 0x00b2, 1, "%s MIDI"),
1659 /* Cakewalk Sonar V-Studio 100 */
1660 EXTERNAL_PORT(0x0582, 0x00eb, 0, "%s MIDI"),
1661 CONTROL_PORT(0x0582, 0x00eb, 1, "%s Control"),
1663 CONTROL_PORT(0x0582, 0x0102, 0, "%s Control"),
1664 EXTERNAL_PORT(0x0582, 0x0102, 1, "%s MIDI"),
1666 EXTERNAL_PORT(0x0582, 0x010f, 0, "%s MIDI"),
1667 CONTROL_PORT(0x0582, 0x010f, 1, "%s 1"),
1668 CONTROL_PORT(0x0582, 0x010f, 2, "%s 2"),
1670 ROLAND_SYNTH_PORT(0x0582, 0x0114, 0, "%s Synth", 128),
1671 EXTERNAL_PORT(0x0582, 0x0114, 1, "%s MIDI"),
1672 CONTROL_PORT(0x0582, 0x0114, 2, "%s Control"),
1673 /* Roland OCTA-CAPTURE */
1674 EXTERNAL_PORT(0x0582, 0x0120, 0, "%s MIDI"),
1675 CONTROL_PORT(0x0582, 0x0120, 1, "%s Control"),
1676 EXTERNAL_PORT(0x0582, 0x0121, 0, "%s MIDI"),
1677 CONTROL_PORT(0x0582, 0x0121, 1, "%s Control"),
1679 CONTROL_PORT(0x0582, 0x0145, 0, "%s Control"),
1680 EXTERNAL_PORT(0x0582, 0x0145, 1, "%s MIDI"),
1681 /* Roland A-Series */
1682 CONTROL_PORT(0x0582, 0x0156, 0, "%s Keyboard"),
1683 EXTERNAL_PORT(0x0582, 0x0156, 1, "%s MIDI"),
1684 /* Roland INTEGRA-7 */
1685 ROLAND_SYNTH_PORT(0x0582, 0x015b, 0, "%s Synth", 128),
1686 CONTROL_PORT(0x0582, 0x015b, 1, "%s Control"),
1687 /* M-Audio MidiSport 8x8 */
1688 CONTROL_PORT(0x0763, 0x1031, 8, "%s Control"),
1689 CONTROL_PORT(0x0763, 0x1033, 8, "%s Control"),
1691 EXTERNAL_PORT(0x07fd, 0x0001, 0, "%s MIDI A"),
1692 EXTERNAL_PORT(0x07fd, 0x0001, 1, "%s MIDI B"),
1693 /* Emagic Unitor8/AMT8/MT4 */
1694 EXTERNAL_PORT(0x086a, 0x0001, 8, "%s Broadcast"),
1695 EXTERNAL_PORT(0x086a, 0x0002, 8, "%s Broadcast"),
1696 EXTERNAL_PORT(0x086a, 0x0003, 4, "%s Broadcast"),
1698 CONTROL_PORT(0x09e8, 0x0062, 0, "%s Control"),
1699 PORT_INFO(0x09e8, 0x0062, 1, "%s MIDI", 0,
1700 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
|
1701 SNDRV_SEQ_PORT_TYPE_HARDWARE
),
1702 /* Access Music Virus TI */
1703 EXTERNAL_PORT(0x133e, 0x0815, 0, "%s MIDI"),
1704 PORT_INFO(0x133e, 0x0815, 1, "%s Synth", 0,
1705 SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
|
1706 SNDRV_SEQ_PORT_TYPE_HARDWARE
|
1707 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER
),
1710 static struct port_info
*find_port_info(struct snd_usb_midi
*umidi
, int number
)
1714 for (i
= 0; i
< ARRAY_SIZE(snd_usbmidi_port_info
); ++i
) {
1715 if (snd_usbmidi_port_info
[i
].id
== umidi
->usb_id
&&
1716 snd_usbmidi_port_info
[i
].port
== number
)
1717 return &snd_usbmidi_port_info
[i
];
1722 static void snd_usbmidi_get_port_info(struct snd_rawmidi
*rmidi
, int number
,
1723 struct snd_seq_port_info
*seq_port_info
)
1725 struct snd_usb_midi
*umidi
= rmidi
->private_data
;
1726 struct port_info
*port_info
;
1728 /* TODO: read port flags from descriptors */
1729 port_info
= find_port_info(umidi
, number
);
1731 seq_port_info
->type
= port_info
->seq_flags
;
1732 seq_port_info
->midi_voices
= port_info
->voices
;
1736 static void snd_usbmidi_init_substream(struct snd_usb_midi
*umidi
,
1737 int stream
, int number
,
1738 struct snd_rawmidi_substream
**rsubstream
)
1740 struct port_info
*port_info
;
1741 const char *name_format
;
1743 struct snd_rawmidi_substream
*substream
=
1744 snd_usbmidi_find_substream(umidi
, stream
, number
);
1746 dev_err(&umidi
->dev
->dev
, "substream %d:%d not found\n", stream
,
1751 /* TODO: read port name from jack descriptor */
1752 port_info
= find_port_info(umidi
, number
);
1753 name_format
= port_info
? port_info
->name
: "%s MIDI %d";
1754 snprintf(substream
->name
, sizeof(substream
->name
),
1755 name_format
, umidi
->card
->shortname
, number
+ 1);
1757 *rsubstream
= substream
;
1761 * Creates the endpoints and their ports.
1763 static int snd_usbmidi_create_endpoints(struct snd_usb_midi
*umidi
,
1764 struct snd_usb_midi_endpoint_info
*endpoints
)
1767 int out_ports
= 0, in_ports
= 0;
1769 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
1770 if (endpoints
[i
].out_cables
) {
1771 err
= snd_usbmidi_out_endpoint_create(umidi
,
1773 &umidi
->endpoints
[i
]);
1777 if (endpoints
[i
].in_cables
) {
1778 err
= snd_usbmidi_in_endpoint_create(umidi
,
1780 &umidi
->endpoints
[i
]);
1785 for (j
= 0; j
< 0x10; ++j
) {
1786 if (endpoints
[i
].out_cables
& (1 << j
)) {
1787 snd_usbmidi_init_substream(umidi
,
1788 SNDRV_RAWMIDI_STREAM_OUTPUT
,
1790 &umidi
->endpoints
[i
].out
->ports
[j
].substream
);
1793 if (endpoints
[i
].in_cables
& (1 << j
)) {
1794 snd_usbmidi_init_substream(umidi
,
1795 SNDRV_RAWMIDI_STREAM_INPUT
,
1797 &umidi
->endpoints
[i
].in
->ports
[j
].substream
);
1802 dev_dbg(&umidi
->dev
->dev
, "created %d output and %d input ports\n",
1803 out_ports
, in_ports
);
1808 * Returns MIDIStreaming device capabilities.
1810 static int snd_usbmidi_get_ms_info(struct snd_usb_midi
*umidi
,
1811 struct snd_usb_midi_endpoint_info
*endpoints
)
1813 struct usb_interface
*intf
;
1814 struct usb_host_interface
*hostif
;
1815 struct usb_interface_descriptor
*intfd
;
1816 struct usb_ms_header_descriptor
*ms_header
;
1817 struct usb_host_endpoint
*hostep
;
1818 struct usb_endpoint_descriptor
*ep
;
1819 struct usb_ms_endpoint_descriptor
*ms_ep
;
1822 intf
= umidi
->iface
;
1825 hostif
= &intf
->altsetting
[0];
1826 intfd
= get_iface_desc(hostif
);
1827 ms_header
= (struct usb_ms_header_descriptor
*)hostif
->extra
;
1828 if (hostif
->extralen
>= 7 &&
1829 ms_header
->bLength
>= 7 &&
1830 ms_header
->bDescriptorType
== USB_DT_CS_INTERFACE
&&
1831 ms_header
->bDescriptorSubtype
== UAC_HEADER
)
1832 dev_dbg(&umidi
->dev
->dev
, "MIDIStreaming version %02x.%02x\n",
1833 ms_header
->bcdMSC
[1], ms_header
->bcdMSC
[0]);
1835 dev_warn(&umidi
->dev
->dev
,
1836 "MIDIStreaming interface descriptor not found\n");
1839 for (i
= 0; i
< intfd
->bNumEndpoints
; ++i
) {
1840 hostep
= &hostif
->endpoint
[i
];
1841 ep
= get_ep_desc(hostep
);
1842 if (!usb_endpoint_xfer_bulk(ep
) && !usb_endpoint_xfer_int(ep
))
1844 ms_ep
= (struct usb_ms_endpoint_descriptor
*)hostep
->extra
;
1845 if (hostep
->extralen
< 4 ||
1846 ms_ep
->bLength
< 4 ||
1847 ms_ep
->bDescriptorType
!= USB_DT_CS_ENDPOINT
||
1848 ms_ep
->bDescriptorSubtype
!= UAC_MS_GENERAL
)
1850 if (usb_endpoint_dir_out(ep
)) {
1851 if (endpoints
[epidx
].out_ep
) {
1852 if (++epidx
>= MIDI_MAX_ENDPOINTS
) {
1853 dev_warn(&umidi
->dev
->dev
,
1854 "too many endpoints\n");
1858 endpoints
[epidx
].out_ep
= usb_endpoint_num(ep
);
1859 if (usb_endpoint_xfer_int(ep
))
1860 endpoints
[epidx
].out_interval
= ep
->bInterval
;
1861 else if (snd_usb_get_speed(umidi
->dev
) == USB_SPEED_LOW
)
1863 * Low speed bulk transfers don't exist, so
1864 * force interrupt transfers for devices like
1865 * ESI MIDI Mate that try to use them anyway.
1867 endpoints
[epidx
].out_interval
= 1;
1868 endpoints
[epidx
].out_cables
=
1869 (1 << ms_ep
->bNumEmbMIDIJack
) - 1;
1870 dev_dbg(&umidi
->dev
->dev
, "EP %02X: %d jack(s)\n",
1871 ep
->bEndpointAddress
, ms_ep
->bNumEmbMIDIJack
);
1873 if (endpoints
[epidx
].in_ep
) {
1874 if (++epidx
>= MIDI_MAX_ENDPOINTS
) {
1875 dev_warn(&umidi
->dev
->dev
,
1876 "too many endpoints\n");
1880 endpoints
[epidx
].in_ep
= usb_endpoint_num(ep
);
1881 if (usb_endpoint_xfer_int(ep
))
1882 endpoints
[epidx
].in_interval
= ep
->bInterval
;
1883 else if (snd_usb_get_speed(umidi
->dev
) == USB_SPEED_LOW
)
1884 endpoints
[epidx
].in_interval
= 1;
1885 endpoints
[epidx
].in_cables
=
1886 (1 << ms_ep
->bNumEmbMIDIJack
) - 1;
1887 dev_dbg(&umidi
->dev
->dev
, "EP %02X: %d jack(s)\n",
1888 ep
->bEndpointAddress
, ms_ep
->bNumEmbMIDIJack
);
1894 static int roland_load_info(struct snd_kcontrol
*kcontrol
,
1895 struct snd_ctl_elem_info
*info
)
1897 static const char *const names
[] = { "High Load", "Light Load" };
1899 return snd_ctl_enum_info(info
, 1, 2, names
);
1902 static int roland_load_get(struct snd_kcontrol
*kcontrol
,
1903 struct snd_ctl_elem_value
*value
)
1905 value
->value
.enumerated
.item
[0] = kcontrol
->private_value
;
1909 static int roland_load_put(struct snd_kcontrol
*kcontrol
,
1910 struct snd_ctl_elem_value
*value
)
1912 struct snd_usb_midi
*umidi
= kcontrol
->private_data
;
1915 if (value
->value
.enumerated
.item
[0] > 1)
1917 mutex_lock(&umidi
->mutex
);
1918 changed
= value
->value
.enumerated
.item
[0] != kcontrol
->private_value
;
1920 kcontrol
->private_value
= value
->value
.enumerated
.item
[0];
1921 mutex_unlock(&umidi
->mutex
);
1925 static const struct snd_kcontrol_new roland_load_ctl
= {
1926 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1927 .name
= "MIDI Input Mode",
1928 .info
= roland_load_info
,
1929 .get
= roland_load_get
,
1930 .put
= roland_load_put
,
1935 * On Roland devices, use the second alternate setting to be able to use
1936 * the interrupt input endpoint.
1938 static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi
*umidi
)
1940 struct usb_interface
*intf
;
1941 struct usb_host_interface
*hostif
;
1942 struct usb_interface_descriptor
*intfd
;
1944 intf
= umidi
->iface
;
1945 if (!intf
|| intf
->num_altsetting
!= 2)
1948 hostif
= &intf
->altsetting
[1];
1949 intfd
= get_iface_desc(hostif
);
1950 /* If either or both of the endpoints support interrupt transfer,
1951 * then use the alternate setting
1953 if (intfd
->bNumEndpoints
!= 2 ||
1954 !((get_endpoint(hostif
, 0)->bmAttributes
&
1955 USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
||
1956 (get_endpoint(hostif
, 1)->bmAttributes
&
1957 USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
))
1960 dev_dbg(&umidi
->dev
->dev
, "switching to altsetting %d with int ep\n",
1961 intfd
->bAlternateSetting
);
1962 usb_set_interface(umidi
->dev
, intfd
->bInterfaceNumber
,
1963 intfd
->bAlternateSetting
);
1965 umidi
->roland_load_ctl
= snd_ctl_new1(&roland_load_ctl
, umidi
);
1966 if (snd_ctl_add(umidi
->card
, umidi
->roland_load_ctl
) < 0)
1967 umidi
->roland_load_ctl
= NULL
;
1971 * Try to find any usable endpoints in the interface.
1973 static int snd_usbmidi_detect_endpoints(struct snd_usb_midi
*umidi
,
1974 struct snd_usb_midi_endpoint_info
*endpoint
,
1977 struct usb_interface
*intf
;
1978 struct usb_host_interface
*hostif
;
1979 struct usb_interface_descriptor
*intfd
;
1980 struct usb_endpoint_descriptor
*epd
;
1981 int i
, out_eps
= 0, in_eps
= 0;
1983 if (USB_ID_VENDOR(umidi
->usb_id
) == 0x0582)
1984 snd_usbmidi_switch_roland_altsetting(umidi
);
1986 if (endpoint
[0].out_ep
|| endpoint
[0].in_ep
)
1989 intf
= umidi
->iface
;
1990 if (!intf
|| intf
->num_altsetting
< 1)
1992 hostif
= intf
->cur_altsetting
;
1993 intfd
= get_iface_desc(hostif
);
1995 for (i
= 0; i
< intfd
->bNumEndpoints
; ++i
) {
1996 epd
= get_endpoint(hostif
, i
);
1997 if (!usb_endpoint_xfer_bulk(epd
) &&
1998 !usb_endpoint_xfer_int(epd
))
2000 if (out_eps
< max_endpoints
&&
2001 usb_endpoint_dir_out(epd
)) {
2002 endpoint
[out_eps
].out_ep
= usb_endpoint_num(epd
);
2003 if (usb_endpoint_xfer_int(epd
))
2004 endpoint
[out_eps
].out_interval
= epd
->bInterval
;
2007 if (in_eps
< max_endpoints
&&
2008 usb_endpoint_dir_in(epd
)) {
2009 endpoint
[in_eps
].in_ep
= usb_endpoint_num(epd
);
2010 if (usb_endpoint_xfer_int(epd
))
2011 endpoint
[in_eps
].in_interval
= epd
->bInterval
;
2015 return (out_eps
|| in_eps
) ? 0 : -ENOENT
;
2019 * Detects the endpoints for one-port-per-endpoint protocols.
2021 static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi
*umidi
,
2022 struct snd_usb_midi_endpoint_info
*endpoints
)
2026 err
= snd_usbmidi_detect_endpoints(umidi
, endpoints
, MIDI_MAX_ENDPOINTS
);
2027 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
2028 if (endpoints
[i
].out_ep
)
2029 endpoints
[i
].out_cables
= 0x0001;
2030 if (endpoints
[i
].in_ep
)
2031 endpoints
[i
].in_cables
= 0x0001;
2037 * Detects the endpoints and ports of Yamaha devices.
2039 static int snd_usbmidi_detect_yamaha(struct snd_usb_midi
*umidi
,
2040 struct snd_usb_midi_endpoint_info
*endpoint
)
2042 struct usb_interface
*intf
;
2043 struct usb_host_interface
*hostif
;
2044 struct usb_interface_descriptor
*intfd
;
2047 intf
= umidi
->iface
;
2050 hostif
= intf
->altsetting
;
2051 intfd
= get_iface_desc(hostif
);
2052 if (intfd
->bNumEndpoints
< 1)
2056 * For each port there is one MIDI_IN/OUT_JACK descriptor, not
2057 * necessarily with any useful contents. So simply count 'em.
2059 for (cs_desc
= hostif
->extra
;
2060 cs_desc
< hostif
->extra
+ hostif
->extralen
&& cs_desc
[0] >= 2;
2061 cs_desc
+= cs_desc
[0]) {
2062 if (cs_desc
[1] == USB_DT_CS_INTERFACE
) {
2063 if (cs_desc
[2] == UAC_MIDI_IN_JACK
)
2064 endpoint
->in_cables
=
2065 (endpoint
->in_cables
<< 1) | 1;
2066 else if (cs_desc
[2] == UAC_MIDI_OUT_JACK
)
2067 endpoint
->out_cables
=
2068 (endpoint
->out_cables
<< 1) | 1;
2071 if (!endpoint
->in_cables
&& !endpoint
->out_cables
)
2074 return snd_usbmidi_detect_endpoints(umidi
, endpoint
, 1);
2078 * Detects the endpoints and ports of Roland devices.
2080 static int snd_usbmidi_detect_roland(struct snd_usb_midi
*umidi
,
2081 struct snd_usb_midi_endpoint_info
*endpoint
)
2083 struct usb_interface
*intf
;
2084 struct usb_host_interface
*hostif
;
2087 intf
= umidi
->iface
;
2090 hostif
= intf
->altsetting
;
2092 * Some devices have a descriptor <06 24 F1 02 <inputs> <outputs>>,
2093 * some have standard class descriptors, or both kinds, or neither.
2095 for (cs_desc
= hostif
->extra
;
2096 cs_desc
< hostif
->extra
+ hostif
->extralen
&& cs_desc
[0] >= 2;
2097 cs_desc
+= cs_desc
[0]) {
2098 if (cs_desc
[0] >= 6 &&
2099 cs_desc
[1] == USB_DT_CS_INTERFACE
&&
2100 cs_desc
[2] == 0xf1 &&
2101 cs_desc
[3] == 0x02) {
2102 endpoint
->in_cables
= (1 << cs_desc
[4]) - 1;
2103 endpoint
->out_cables
= (1 << cs_desc
[5]) - 1;
2104 return snd_usbmidi_detect_endpoints(umidi
, endpoint
, 1);
2105 } else if (cs_desc
[0] >= 7 &&
2106 cs_desc
[1] == USB_DT_CS_INTERFACE
&&
2107 cs_desc
[2] == UAC_HEADER
) {
2108 return snd_usbmidi_get_ms_info(umidi
, endpoint
);
2116 * Creates the endpoints and their ports for Midiman devices.
2118 static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi
*umidi
,
2119 struct snd_usb_midi_endpoint_info
*endpoint
)
2121 struct snd_usb_midi_endpoint_info ep_info
;
2122 struct usb_interface
*intf
;
2123 struct usb_host_interface
*hostif
;
2124 struct usb_interface_descriptor
*intfd
;
2125 struct usb_endpoint_descriptor
*epd
;
2128 intf
= umidi
->iface
;
2131 hostif
= intf
->altsetting
;
2132 intfd
= get_iface_desc(hostif
);
2134 * The various MidiSport devices have more or less random endpoint
2135 * numbers, so we have to identify the endpoints by their index in
2136 * the descriptor array, like the driver for that other OS does.
2138 * There is one interrupt input endpoint for all input ports, one
2139 * bulk output endpoint for even-numbered ports, and one for odd-
2140 * numbered ports. Both bulk output endpoints have corresponding
2141 * input bulk endpoints (at indices 1 and 3) which aren't used.
2143 if (intfd
->bNumEndpoints
< (endpoint
->out_cables
> 0x0001 ? 5 : 3)) {
2144 dev_dbg(&umidi
->dev
->dev
, "not enough endpoints\n");
2148 epd
= get_endpoint(hostif
, 0);
2149 if (!usb_endpoint_dir_in(epd
) || !usb_endpoint_xfer_int(epd
)) {
2150 dev_dbg(&umidi
->dev
->dev
, "endpoint[0] isn't interrupt\n");
2153 epd
= get_endpoint(hostif
, 2);
2154 if (!usb_endpoint_dir_out(epd
) || !usb_endpoint_xfer_bulk(epd
)) {
2155 dev_dbg(&umidi
->dev
->dev
, "endpoint[2] isn't bulk output\n");
2158 if (endpoint
->out_cables
> 0x0001) {
2159 epd
= get_endpoint(hostif
, 4);
2160 if (!usb_endpoint_dir_out(epd
) ||
2161 !usb_endpoint_xfer_bulk(epd
)) {
2162 dev_dbg(&umidi
->dev
->dev
,
2163 "endpoint[4] isn't bulk output\n");
2168 ep_info
.out_ep
= get_endpoint(hostif
, 2)->bEndpointAddress
&
2169 USB_ENDPOINT_NUMBER_MASK
;
2170 ep_info
.out_interval
= 0;
2171 ep_info
.out_cables
= endpoint
->out_cables
& 0x5555;
2172 err
= snd_usbmidi_out_endpoint_create(umidi
, &ep_info
,
2173 &umidi
->endpoints
[0]);
2177 ep_info
.in_ep
= get_endpoint(hostif
, 0)->bEndpointAddress
&
2178 USB_ENDPOINT_NUMBER_MASK
;
2179 ep_info
.in_interval
= get_endpoint(hostif
, 0)->bInterval
;
2180 ep_info
.in_cables
= endpoint
->in_cables
;
2181 err
= snd_usbmidi_in_endpoint_create(umidi
, &ep_info
,
2182 &umidi
->endpoints
[0]);
2186 if (endpoint
->out_cables
> 0x0001) {
2187 ep_info
.out_ep
= get_endpoint(hostif
, 4)->bEndpointAddress
&
2188 USB_ENDPOINT_NUMBER_MASK
;
2189 ep_info
.out_cables
= endpoint
->out_cables
& 0xaaaa;
2190 err
= snd_usbmidi_out_endpoint_create(umidi
, &ep_info
,
2191 &umidi
->endpoints
[1]);
2196 for (cable
= 0; cable
< 0x10; ++cable
) {
2197 if (endpoint
->out_cables
& (1 << cable
))
2198 snd_usbmidi_init_substream(umidi
,
2199 SNDRV_RAWMIDI_STREAM_OUTPUT
,
2201 &umidi
->endpoints
[cable
& 1].out
->ports
[cable
].substream
);
2202 if (endpoint
->in_cables
& (1 << cable
))
2203 snd_usbmidi_init_substream(umidi
,
2204 SNDRV_RAWMIDI_STREAM_INPUT
,
2206 &umidi
->endpoints
[0].in
->ports
[cable
].substream
);
2211 static const struct snd_rawmidi_global_ops snd_usbmidi_ops
= {
2212 .get_port_info
= snd_usbmidi_get_port_info
,
2215 static int snd_usbmidi_create_rawmidi(struct snd_usb_midi
*umidi
,
2216 int out_ports
, int in_ports
)
2218 struct snd_rawmidi
*rmidi
;
2221 err
= snd_rawmidi_new(umidi
->card
, "USB MIDI",
2222 umidi
->next_midi_device
++,
2223 out_ports
, in_ports
, &rmidi
);
2226 strcpy(rmidi
->name
, umidi
->card
->shortname
);
2227 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_OUTPUT
|
2228 SNDRV_RAWMIDI_INFO_INPUT
|
2229 SNDRV_RAWMIDI_INFO_DUPLEX
;
2230 rmidi
->ops
= &snd_usbmidi_ops
;
2231 rmidi
->private_data
= umidi
;
2232 rmidi
->private_free
= snd_usbmidi_rawmidi_free
;
2233 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
,
2234 &snd_usbmidi_output_ops
);
2235 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
,
2236 &snd_usbmidi_input_ops
);
2238 umidi
->rmidi
= rmidi
;
2243 * Temporarily stop input.
2245 void snd_usbmidi_input_stop(struct list_head
*p
)
2247 struct snd_usb_midi
*umidi
;
2250 umidi
= list_entry(p
, struct snd_usb_midi
, list
);
2251 if (!umidi
->input_running
)
2253 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
2254 struct snd_usb_midi_endpoint
*ep
= &umidi
->endpoints
[i
];
2256 for (j
= 0; j
< INPUT_URBS
; ++j
)
2257 usb_kill_urb(ep
->in
->urbs
[j
]);
2259 umidi
->input_running
= 0;
2261 EXPORT_SYMBOL(snd_usbmidi_input_stop
);
2263 static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint
*ep
)
2269 for (i
= 0; i
< INPUT_URBS
; ++i
) {
2270 struct urb
*urb
= ep
->urbs
[i
];
2271 urb
->dev
= ep
->umidi
->dev
;
2272 snd_usbmidi_submit_urb(urb
, GFP_KERNEL
);
2277 * Resume input after a call to snd_usbmidi_input_stop().
2279 void snd_usbmidi_input_start(struct list_head
*p
)
2281 struct snd_usb_midi
*umidi
;
2284 umidi
= list_entry(p
, struct snd_usb_midi
, list
);
2285 if (umidi
->input_running
|| !umidi
->opened
[1])
2287 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
)
2288 snd_usbmidi_input_start_ep(umidi
->endpoints
[i
].in
);
2289 umidi
->input_running
= 1;
2291 EXPORT_SYMBOL(snd_usbmidi_input_start
);
2294 * Prepare for suspend. Typically called from the USB suspend callback.
2296 void snd_usbmidi_suspend(struct list_head
*p
)
2298 struct snd_usb_midi
*umidi
;
2300 umidi
= list_entry(p
, struct snd_usb_midi
, list
);
2301 mutex_lock(&umidi
->mutex
);
2302 snd_usbmidi_input_stop(p
);
2303 mutex_unlock(&umidi
->mutex
);
2305 EXPORT_SYMBOL(snd_usbmidi_suspend
);
2308 * Resume. Typically called from the USB resume callback.
2310 void snd_usbmidi_resume(struct list_head
*p
)
2312 struct snd_usb_midi
*umidi
;
2314 umidi
= list_entry(p
, struct snd_usb_midi
, list
);
2315 mutex_lock(&umidi
->mutex
);
2316 snd_usbmidi_input_start(p
);
2317 mutex_unlock(&umidi
->mutex
);
2319 EXPORT_SYMBOL(snd_usbmidi_resume
);
2322 * Creates and registers everything needed for a MIDI streaming interface.
2324 int __snd_usbmidi_create(struct snd_card
*card
,
2325 struct usb_interface
*iface
,
2326 struct list_head
*midi_list
,
2327 const struct snd_usb_audio_quirk
*quirk
,
2328 unsigned int usb_id
)
2330 struct snd_usb_midi
*umidi
;
2331 struct snd_usb_midi_endpoint_info endpoints
[MIDI_MAX_ENDPOINTS
];
2332 int out_ports
, in_ports
;
2335 umidi
= kzalloc(sizeof(*umidi
), GFP_KERNEL
);
2338 umidi
->dev
= interface_to_usbdev(iface
);
2340 umidi
->iface
= iface
;
2341 umidi
->quirk
= quirk
;
2342 umidi
->usb_protocol_ops
= &snd_usbmidi_standard_ops
;
2343 spin_lock_init(&umidi
->disc_lock
);
2344 init_rwsem(&umidi
->disc_rwsem
);
2345 mutex_init(&umidi
->mutex
);
2347 usb_id
= USB_ID(le16_to_cpu(umidi
->dev
->descriptor
.idVendor
),
2348 le16_to_cpu(umidi
->dev
->descriptor
.idProduct
));
2349 umidi
->usb_id
= usb_id
;
2350 setup_timer(&umidi
->error_timer
, snd_usbmidi_error_timer
,
2351 (unsigned long)umidi
);
2353 /* detect the endpoint(s) to use */
2354 memset(endpoints
, 0, sizeof(endpoints
));
2355 switch (quirk
? quirk
->type
: QUIRK_MIDI_STANDARD_INTERFACE
) {
2356 case QUIRK_MIDI_STANDARD_INTERFACE
:
2357 err
= snd_usbmidi_get_ms_info(umidi
, endpoints
);
2358 if (umidi
->usb_id
== USB_ID(0x0763, 0x0150)) /* M-Audio Uno */
2359 umidi
->usb_protocol_ops
=
2360 &snd_usbmidi_maudio_broken_running_status_ops
;
2362 case QUIRK_MIDI_US122L
:
2363 umidi
->usb_protocol_ops
= &snd_usbmidi_122l_ops
;
2365 case QUIRK_MIDI_FIXED_ENDPOINT
:
2366 memcpy(&endpoints
[0], quirk
->data
,
2367 sizeof(struct snd_usb_midi_endpoint_info
));
2368 err
= snd_usbmidi_detect_endpoints(umidi
, &endpoints
[0], 1);
2370 case QUIRK_MIDI_YAMAHA
:
2371 err
= snd_usbmidi_detect_yamaha(umidi
, &endpoints
[0]);
2373 case QUIRK_MIDI_ROLAND
:
2374 err
= snd_usbmidi_detect_roland(umidi
, &endpoints
[0]);
2376 case QUIRK_MIDI_MIDIMAN
:
2377 umidi
->usb_protocol_ops
= &snd_usbmidi_midiman_ops
;
2378 memcpy(&endpoints
[0], quirk
->data
,
2379 sizeof(struct snd_usb_midi_endpoint_info
));
2382 case QUIRK_MIDI_NOVATION
:
2383 umidi
->usb_protocol_ops
= &snd_usbmidi_novation_ops
;
2384 err
= snd_usbmidi_detect_per_port_endpoints(umidi
, endpoints
);
2386 case QUIRK_MIDI_RAW_BYTES
:
2387 umidi
->usb_protocol_ops
= &snd_usbmidi_raw_ops
;
2389 * Interface 1 contains isochronous endpoints, but with the same
2390 * numbers as in interface 0. Since it is interface 1 that the
2391 * USB core has most recently seen, these descriptors are now
2392 * associated with the endpoint numbers. This will foul up our
2393 * attempts to submit bulk/interrupt URBs to the endpoints in
2394 * interface 0, so we have to make sure that the USB core looks
2395 * again at interface 0 by calling usb_set_interface() on it.
2397 if (umidi
->usb_id
== USB_ID(0x07fd, 0x0001)) /* MOTU Fastlane */
2398 usb_set_interface(umidi
->dev
, 0, 0);
2399 err
= snd_usbmidi_detect_per_port_endpoints(umidi
, endpoints
);
2401 case QUIRK_MIDI_EMAGIC
:
2402 umidi
->usb_protocol_ops
= &snd_usbmidi_emagic_ops
;
2403 memcpy(&endpoints
[0], quirk
->data
,
2404 sizeof(struct snd_usb_midi_endpoint_info
));
2405 err
= snd_usbmidi_detect_endpoints(umidi
, &endpoints
[0], 1);
2407 case QUIRK_MIDI_CME
:
2408 umidi
->usb_protocol_ops
= &snd_usbmidi_cme_ops
;
2409 err
= snd_usbmidi_detect_per_port_endpoints(umidi
, endpoints
);
2411 case QUIRK_MIDI_AKAI
:
2412 umidi
->usb_protocol_ops
= &snd_usbmidi_akai_ops
;
2413 err
= snd_usbmidi_detect_per_port_endpoints(umidi
, endpoints
);
2414 /* endpoint 1 is input-only */
2415 endpoints
[1].out_cables
= 0;
2417 case QUIRK_MIDI_FTDI
:
2418 umidi
->usb_protocol_ops
= &snd_usbmidi_ftdi_ops
;
2420 /* set baud rate to 31250 (48 MHz / 16 / 96) */
2421 err
= usb_control_msg(umidi
->dev
, usb_sndctrlpipe(umidi
->dev
, 0),
2422 3, 0x40, 0x60, 0, NULL
, 0, 1000);
2426 err
= snd_usbmidi_detect_per_port_endpoints(umidi
, endpoints
);
2428 case QUIRK_MIDI_CH345
:
2429 umidi
->usb_protocol_ops
= &snd_usbmidi_ch345_broken_sysex_ops
;
2430 err
= snd_usbmidi_detect_per_port_endpoints(umidi
, endpoints
);
2433 dev_err(&umidi
->dev
->dev
, "invalid quirk type %d\n",
2441 /* create rawmidi device */
2444 for (i
= 0; i
< MIDI_MAX_ENDPOINTS
; ++i
) {
2445 out_ports
+= hweight16(endpoints
[i
].out_cables
);
2446 in_ports
+= hweight16(endpoints
[i
].in_cables
);
2448 err
= snd_usbmidi_create_rawmidi(umidi
, out_ports
, in_ports
);
2452 /* create endpoint/port structures */
2453 if (quirk
&& quirk
->type
== QUIRK_MIDI_MIDIMAN
)
2454 err
= snd_usbmidi_create_endpoints_midiman(umidi
, &endpoints
[0]);
2456 err
= snd_usbmidi_create_endpoints(umidi
, endpoints
);
2460 usb_autopm_get_interface_no_resume(umidi
->iface
);
2462 list_add_tail(&umidi
->list
, midi_list
);
2470 EXPORT_SYMBOL(__snd_usbmidi_create
);