2 * f_midi.c -- USB MIDI class function driver
4 * Copyright (C) 2006 Thumtronics Pty Ltd.
5 * Developed for Thumtronics by Grey Innovation
6 * Ben Williamson <ben.williamson@greyinnovation.com>
8 * Rewritten for the composite framework
9 * Copyright (C) 2011 Daniel Mack <zonque@gmail.com>
11 * Based on drivers/usb/gadget/f_audio.c,
12 * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
13 * Copyright (C) 2008 Analog Devices, Inc
15 * and drivers/usb/gadget/midi.c,
16 * Copyright (C) 2006 Thumtronics Pty Ltd.
17 * Ben Williamson <ben.williamson@greyinnovation.com>
19 * Licensed under the GPL-2 or later.
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/device.h>
27 #include <sound/core.h>
28 #include <sound/initval.h>
29 #include <sound/rawmidi.h>
31 #include <linux/usb/ch9.h>
32 #include <linux/usb/gadget.h>
33 #include <linux/usb/audio.h>
34 #include <linux/usb/midi.h>
39 MODULE_AUTHOR("Ben Williamson");
40 MODULE_LICENSE("GPL v2");
42 static const char f_midi_shortname
[] = "f_midi";
43 static const char f_midi_longname
[] = "MIDI Gadget";
46 * We can only handle 16 cables on one single endpoint, as cable numbers are
47 * stored in 4-bit fields. And as the interface currently only holds one
48 * single endpoint, this is the maximum number of ports we can allow.
53 * This is a gadget, and the IN/OUT naming is from the host's perspective.
54 * USB -> OUT endpoint -> rawmidi
55 * USB <- IN endpoint <- rawmidi
57 struct gmidi_in_port
{
62 #define STATE_UNKNOWN 0
63 #define STATE_1PARAM 1
64 #define STATE_2PARAM_1 2
65 #define STATE_2PARAM_2 3
66 #define STATE_SYSEX_0 4
67 #define STATE_SYSEX_1 5
68 #define STATE_SYSEX_2 6
73 struct usb_function func
;
74 struct usb_gadget
*gadget
;
75 struct usb_ep
*in_ep
, *out_ep
;
76 struct snd_card
*card
;
77 struct snd_rawmidi
*rmidi
;
79 struct snd_rawmidi_substream
*in_substream
[MAX_PORTS
];
80 struct snd_rawmidi_substream
*out_substream
[MAX_PORTS
];
81 struct gmidi_in_port
*in_port
[MAX_PORTS
];
83 unsigned long out_triggered
;
84 struct tasklet_struct tasklet
;
85 unsigned int in_ports
;
86 unsigned int out_ports
;
89 unsigned int buflen
, qlen
;
92 static inline struct f_midi
*func_to_midi(struct usb_function
*f
)
94 return container_of(f
, struct f_midi
, func
);
97 static void f_midi_transmit(struct f_midi
*midi
, struct usb_request
*req
);
99 DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
100 DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
101 DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
103 /* B.3.1 Standard AC Interface Descriptor */
104 static struct usb_interface_descriptor ac_interface_desc
= {
105 .bLength
= USB_DT_INTERFACE_SIZE
,
106 .bDescriptorType
= USB_DT_INTERFACE
,
107 /* .bInterfaceNumber = DYNAMIC */
108 /* .bNumEndpoints = DYNAMIC */
109 .bInterfaceClass
= USB_CLASS_AUDIO
,
110 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOCONTROL
,
111 /* .iInterface = DYNAMIC */
114 /* B.3.2 Class-Specific AC Interface Descriptor */
115 static struct uac1_ac_header_descriptor_1 ac_header_desc
= {
116 .bLength
= UAC_DT_AC_HEADER_SIZE(1),
117 .bDescriptorType
= USB_DT_CS_INTERFACE
,
118 .bDescriptorSubtype
= USB_MS_HEADER
,
119 .bcdADC
= cpu_to_le16(0x0100),
120 .wTotalLength
= cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
122 /* .baInterfaceNr = DYNAMIC */
125 /* B.4.1 Standard MS Interface Descriptor */
126 static struct usb_interface_descriptor ms_interface_desc
= {
127 .bLength
= USB_DT_INTERFACE_SIZE
,
128 .bDescriptorType
= USB_DT_INTERFACE
,
129 /* .bInterfaceNumber = DYNAMIC */
131 .bInterfaceClass
= USB_CLASS_AUDIO
,
132 .bInterfaceSubClass
= USB_SUBCLASS_MIDISTREAMING
,
133 /* .iInterface = DYNAMIC */
136 /* B.4.2 Class-Specific MS Interface Descriptor */
137 static struct usb_ms_header_descriptor ms_header_desc
= {
138 .bLength
= USB_DT_MS_HEADER_SIZE
,
139 .bDescriptorType
= USB_DT_CS_INTERFACE
,
140 .bDescriptorSubtype
= USB_MS_HEADER
,
141 .bcdMSC
= cpu_to_le16(0x0100),
142 /* .wTotalLength = DYNAMIC */
145 /* B.5.1 Standard Bulk OUT Endpoint Descriptor */
146 static struct usb_endpoint_descriptor bulk_out_desc
= {
147 .bLength
= USB_DT_ENDPOINT_AUDIO_SIZE
,
148 .bDescriptorType
= USB_DT_ENDPOINT
,
149 .bEndpointAddress
= USB_DIR_OUT
,
150 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
153 /* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */
154 static struct usb_ms_endpoint_descriptor_16 ms_out_desc
= {
155 /* .bLength = DYNAMIC */
156 .bDescriptorType
= USB_DT_CS_ENDPOINT
,
157 .bDescriptorSubtype
= USB_MS_GENERAL
,
158 /* .bNumEmbMIDIJack = DYNAMIC */
159 /* .baAssocJackID = DYNAMIC */
162 /* B.6.1 Standard Bulk IN Endpoint Descriptor */
163 static struct usb_endpoint_descriptor bulk_in_desc
= {
164 .bLength
= USB_DT_ENDPOINT_AUDIO_SIZE
,
165 .bDescriptorType
= USB_DT_ENDPOINT
,
166 .bEndpointAddress
= USB_DIR_IN
,
167 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
170 /* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */
171 static struct usb_ms_endpoint_descriptor_16 ms_in_desc
= {
172 /* .bLength = DYNAMIC */
173 .bDescriptorType
= USB_DT_CS_ENDPOINT
,
174 .bDescriptorSubtype
= USB_MS_GENERAL
,
175 /* .bNumEmbMIDIJack = DYNAMIC */
176 /* .baAssocJackID = DYNAMIC */
179 /* string IDs are assigned dynamically */
181 #define STRING_FUNC_IDX 0
183 static struct usb_string midi_string_defs
[] = {
184 [STRING_FUNC_IDX
].s
= "MIDI function",
185 { } /* end of list */
188 static struct usb_gadget_strings midi_stringtab
= {
189 .language
= 0x0409, /* en-us */
190 .strings
= midi_string_defs
,
193 static struct usb_gadget_strings
*midi_strings
[] = {
198 static inline struct usb_request
*midi_alloc_ep_req(struct usb_ep
*ep
,
201 return alloc_ep_req(ep
, length
, length
);
204 static void free_ep_req(struct usb_ep
*ep
, struct usb_request
*req
)
207 usb_ep_free_request(ep
, req
);
210 static const uint8_t f_midi_cin_length
[] = {
211 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
215 * Receives a chunk of MIDI data.
217 static void f_midi_read_data(struct usb_ep
*ep
, int cable
,
218 uint8_t *data
, int length
)
220 struct f_midi
*midi
= ep
->driver_data
;
221 struct snd_rawmidi_substream
*substream
= midi
->out_substream
[cable
];
224 /* Nobody is listening - throw it on the floor. */
227 if (!test_bit(cable
, &midi
->out_triggered
))
230 snd_rawmidi_receive(substream
, data
, length
);
233 static void f_midi_handle_out_data(struct usb_ep
*ep
, struct usb_request
*req
)
238 for (i
= 0; i
+ 3 < req
->actual
; i
+= 4)
240 int cable
= buf
[i
] >> 4;
241 int length
= f_midi_cin_length
[buf
[i
] & 0x0f];
242 f_midi_read_data(ep
, cable
, &buf
[i
+ 1], length
);
247 f_midi_complete(struct usb_ep
*ep
, struct usb_request
*req
)
249 struct f_midi
*midi
= ep
->driver_data
;
250 struct usb_composite_dev
*cdev
= midi
->func
.config
->cdev
;
251 int status
= req
->status
;
254 case 0: /* normal completion */
255 if (ep
== midi
->out_ep
) {
256 /* We received stuff. req is queued again, below */
257 f_midi_handle_out_data(ep
, req
);
258 } else if (ep
== midi
->in_ep
) {
259 /* Our transmit completed. See if there's more to go.
260 * f_midi_transmit eats req, don't queue it again. */
261 f_midi_transmit(midi
, req
);
266 /* this endpoint is normally active while we're configured */
267 case -ECONNABORTED
: /* hardware forced ep reset */
268 case -ECONNRESET
: /* request dequeued */
269 case -ESHUTDOWN
: /* disconnect from host */
270 VDBG(cdev
, "%s gone (%d), %d/%d\n", ep
->name
, status
,
271 req
->actual
, req
->length
);
272 if (ep
== midi
->out_ep
)
273 f_midi_handle_out_data(ep
, req
);
275 free_ep_req(ep
, req
);
278 case -EOVERFLOW
: /* buffer overrun on read means that
279 * we didn't provide a big enough buffer.
282 DBG(cdev
, "%s complete --> %d, %d/%d\n", ep
->name
,
283 status
, req
->actual
, req
->length
);
285 case -EREMOTEIO
: /* short read */
289 status
= usb_ep_queue(ep
, req
, GFP_ATOMIC
);
291 ERROR(cdev
, "kill %s: resubmit %d bytes --> %d\n",
292 ep
->name
, req
->length
, status
);
294 /* FIXME recover later ... somehow */
298 static int f_midi_start_ep(struct f_midi
*midi
,
299 struct usb_function
*f
,
303 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
308 err
= config_ep_by_speed(midi
->gadget
, f
, ep
);
310 ERROR(cdev
, "can't configure %s: %d\n", ep
->name
, err
);
314 err
= usb_ep_enable(ep
);
316 ERROR(cdev
, "can't start %s: %d\n", ep
->name
, err
);
320 ep
->driver_data
= midi
;
325 static int f_midi_set_alt(struct usb_function
*f
, unsigned intf
, unsigned alt
)
327 struct f_midi
*midi
= func_to_midi(f
);
328 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
332 /* For Control Device interface we do nothing */
336 err
= f_midi_start_ep(midi
, f
, midi
->in_ep
);
340 err
= f_midi_start_ep(midi
, f
, midi
->out_ep
);
344 if (midi
->out_ep
->driver_data
)
345 usb_ep_disable(midi
->out_ep
);
347 err
= config_ep_by_speed(midi
->gadget
, f
, midi
->out_ep
);
349 ERROR(cdev
, "can't configure %s: %d\n",
350 midi
->out_ep
->name
, err
);
354 err
= usb_ep_enable(midi
->out_ep
);
356 ERROR(cdev
, "can't start %s: %d\n",
357 midi
->out_ep
->name
, err
);
361 midi
->out_ep
->driver_data
= midi
;
363 /* allocate a bunch of read buffers and queue them all at once. */
364 for (i
= 0; i
< midi
->qlen
&& err
== 0; i
++) {
365 struct usb_request
*req
=
366 midi_alloc_ep_req(midi
->out_ep
, midi
->buflen
);
370 req
->complete
= f_midi_complete
;
371 err
= usb_ep_queue(midi
->out_ep
, req
, GFP_ATOMIC
);
373 ERROR(midi
, "%s queue req: %d\n",
374 midi
->out_ep
->name
, err
);
381 static void f_midi_disable(struct usb_function
*f
)
383 struct f_midi
*midi
= func_to_midi(f
);
384 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
386 DBG(cdev
, "disable\n");
389 * just disable endpoints, forcing completion of pending i/o.
390 * all our completion handlers free their requests in this case.
392 usb_ep_disable(midi
->in_ep
);
393 usb_ep_disable(midi
->out_ep
);
396 static int f_midi_snd_free(struct snd_device
*device
)
401 static void f_midi_transmit_packet(struct usb_request
*req
, uint8_t p0
,
402 uint8_t p1
, uint8_t p2
, uint8_t p3
)
404 unsigned length
= req
->length
;
405 u8
*buf
= (u8
*)req
->buf
+ length
;
411 req
->length
= length
+ 4;
415 * Converts MIDI commands to USB MIDI packets.
417 static void f_midi_transmit_byte(struct usb_request
*req
,
418 struct gmidi_in_port
*port
, uint8_t b
)
420 uint8_t p0
= port
->cable
<< 4;
423 f_midi_transmit_packet(req
, p0
| 0x0f, b
, 0, 0);
424 } else if (b
>= 0xf0) {
428 port
->state
= STATE_SYSEX_1
;
433 port
->state
= STATE_1PARAM
;
437 port
->state
= STATE_2PARAM_1
;
441 port
->state
= STATE_UNKNOWN
;
444 f_midi_transmit_packet(req
, p0
| 0x05, 0xf6, 0, 0);
445 port
->state
= STATE_UNKNOWN
;
448 switch (port
->state
) {
450 f_midi_transmit_packet(req
,
451 p0
| 0x05, 0xf7, 0, 0);
454 f_midi_transmit_packet(req
,
455 p0
| 0x06, port
->data
[0], 0xf7, 0);
458 f_midi_transmit_packet(req
,
459 p0
| 0x07, port
->data
[0],
460 port
->data
[1], 0xf7);
463 port
->state
= STATE_UNKNOWN
;
466 } else if (b
>= 0x80) {
468 if (b
>= 0xc0 && b
<= 0xdf)
469 port
->state
= STATE_1PARAM
;
471 port
->state
= STATE_2PARAM_1
;
472 } else { /* b < 0x80 */
473 switch (port
->state
) {
475 if (port
->data
[0] < 0xf0) {
476 p0
|= port
->data
[0] >> 4;
479 port
->state
= STATE_UNKNOWN
;
481 f_midi_transmit_packet(req
, p0
, port
->data
[0], b
, 0);
485 port
->state
= STATE_2PARAM_2
;
488 if (port
->data
[0] < 0xf0) {
489 p0
|= port
->data
[0] >> 4;
490 port
->state
= STATE_2PARAM_1
;
493 port
->state
= STATE_UNKNOWN
;
495 f_midi_transmit_packet(req
,
496 p0
, port
->data
[0], port
->data
[1], b
);
500 port
->state
= STATE_SYSEX_1
;
504 port
->state
= STATE_SYSEX_2
;
507 f_midi_transmit_packet(req
,
508 p0
| 0x04, port
->data
[0], port
->data
[1], b
);
509 port
->state
= STATE_SYSEX_0
;
515 static void f_midi_transmit(struct f_midi
*midi
, struct usb_request
*req
)
517 struct usb_ep
*ep
= midi
->in_ep
;
524 req
= midi_alloc_ep_req(ep
, midi
->buflen
);
527 ERROR(midi
, "%s: alloc_ep_request failed\n", __func__
);
531 req
->complete
= f_midi_complete
;
533 for (i
= 0; i
< MAX_PORTS
; i
++) {
534 struct gmidi_in_port
*port
= midi
->in_port
[i
];
535 struct snd_rawmidi_substream
*substream
= midi
->in_substream
[i
];
537 if (!port
|| !port
->active
|| !substream
)
540 while (req
->length
+ 3 < midi
->buflen
) {
542 if (snd_rawmidi_transmit(substream
, &b
, 1) != 1) {
546 f_midi_transmit_byte(req
, port
, b
);
551 usb_ep_queue(ep
, req
, GFP_ATOMIC
);
553 free_ep_req(ep
, req
);
556 static void f_midi_in_tasklet(unsigned long data
)
558 struct f_midi
*midi
= (struct f_midi
*) data
;
559 f_midi_transmit(midi
, NULL
);
562 static int f_midi_in_open(struct snd_rawmidi_substream
*substream
)
564 struct f_midi
*midi
= substream
->rmidi
->private_data
;
566 if (!midi
->in_port
[substream
->number
])
569 VDBG(midi
, "%s()\n", __func__
);
570 midi
->in_substream
[substream
->number
] = substream
;
571 midi
->in_port
[substream
->number
]->state
= STATE_UNKNOWN
;
575 static int f_midi_in_close(struct snd_rawmidi_substream
*substream
)
577 struct f_midi
*midi
= substream
->rmidi
->private_data
;
579 VDBG(midi
, "%s()\n", __func__
);
583 static void f_midi_in_trigger(struct snd_rawmidi_substream
*substream
, int up
)
585 struct f_midi
*midi
= substream
->rmidi
->private_data
;
587 if (!midi
->in_port
[substream
->number
])
590 VDBG(midi
, "%s() %d\n", __func__
, up
);
591 midi
->in_port
[substream
->number
]->active
= up
;
593 tasklet_hi_schedule(&midi
->tasklet
);
596 static int f_midi_out_open(struct snd_rawmidi_substream
*substream
)
598 struct f_midi
*midi
= substream
->rmidi
->private_data
;
600 if (substream
->number
>= MAX_PORTS
)
603 VDBG(midi
, "%s()\n", __func__
);
604 midi
->out_substream
[substream
->number
] = substream
;
608 static int f_midi_out_close(struct snd_rawmidi_substream
*substream
)
610 struct f_midi
*midi
= substream
->rmidi
->private_data
;
612 VDBG(midi
, "%s()\n", __func__
);
616 static void f_midi_out_trigger(struct snd_rawmidi_substream
*substream
, int up
)
618 struct f_midi
*midi
= substream
->rmidi
->private_data
;
620 VDBG(midi
, "%s()\n", __func__
);
623 set_bit(substream
->number
, &midi
->out_triggered
);
625 clear_bit(substream
->number
, &midi
->out_triggered
);
628 static struct snd_rawmidi_ops gmidi_in_ops
= {
629 .open
= f_midi_in_open
,
630 .close
= f_midi_in_close
,
631 .trigger
= f_midi_in_trigger
,
634 static struct snd_rawmidi_ops gmidi_out_ops
= {
635 .open
= f_midi_out_open
,
636 .close
= f_midi_out_close
,
637 .trigger
= f_midi_out_trigger
640 static inline void f_midi_unregister_card(struct f_midi
*midi
)
643 snd_card_free(midi
->card
);
648 /* register as a sound "card" */
649 static int f_midi_register_card(struct f_midi
*midi
)
651 struct snd_card
*card
;
652 struct snd_rawmidi
*rmidi
;
654 static struct snd_device_ops ops
= {
655 .dev_free
= f_midi_snd_free
,
658 err
= snd_card_new(&midi
->gadget
->dev
, midi
->index
, midi
->id
,
659 THIS_MODULE
, 0, &card
);
661 ERROR(midi
, "snd_card_new() failed\n");
666 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, midi
, &ops
);
668 ERROR(midi
, "snd_device_new() failed: error %d\n", err
);
672 strcpy(card
->driver
, f_midi_longname
);
673 strcpy(card
->longname
, f_midi_longname
);
674 strcpy(card
->shortname
, f_midi_shortname
);
677 snd_component_add(card
, "MIDI");
678 err
= snd_rawmidi_new(card
, card
->longname
, 0,
679 midi
->out_ports
, midi
->in_ports
, &rmidi
);
681 ERROR(midi
, "snd_rawmidi_new() failed: error %d\n", err
);
685 strcpy(rmidi
->name
, card
->shortname
);
686 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_OUTPUT
|
687 SNDRV_RAWMIDI_INFO_INPUT
|
688 SNDRV_RAWMIDI_INFO_DUPLEX
;
689 rmidi
->private_data
= midi
;
692 * Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT.
693 * It's an upside-down world being a gadget.
695 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
, &gmidi_in_ops
);
696 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
, &gmidi_out_ops
);
698 /* register it - we're ready to go */
699 err
= snd_card_register(card
);
701 ERROR(midi
, "snd_card_register() failed\n");
705 VDBG(midi
, "%s() finished ok\n", __func__
);
709 f_midi_unregister_card(midi
);
713 /* MIDI function driver setup/binding */
715 static int f_midi_bind(struct usb_configuration
*c
, struct usb_function
*f
)
717 struct usb_descriptor_header
**midi_function
;
718 struct usb_midi_in_jack_descriptor jack_in_ext_desc
[MAX_PORTS
];
719 struct usb_midi_in_jack_descriptor jack_in_emb_desc
[MAX_PORTS
];
720 struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc
[MAX_PORTS
];
721 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc
[MAX_PORTS
];
722 struct usb_composite_dev
*cdev
= c
->cdev
;
723 struct f_midi
*midi
= func_to_midi(f
);
724 struct usb_string
*us
;
725 int status
, n
, jack
= 1, i
= 0;
727 midi
->gadget
= cdev
->gadget
;
728 tasklet_init(&midi
->tasklet
, f_midi_in_tasklet
, (unsigned long) midi
);
729 status
= f_midi_register_card(midi
);
733 /* maybe allocate device-global string ID */
734 us
= usb_gstrings_attach(c
->cdev
, midi_strings
,
735 ARRAY_SIZE(midi_string_defs
));
737 status
= PTR_ERR(us
);
740 ac_interface_desc
.iInterface
= us
[STRING_FUNC_IDX
].id
;
742 /* We have two interfaces, AudioControl and MIDIStreaming */
743 status
= usb_interface_id(c
, f
);
746 ac_interface_desc
.bInterfaceNumber
= status
;
748 status
= usb_interface_id(c
, f
);
751 ms_interface_desc
.bInterfaceNumber
= status
;
752 ac_header_desc
.baInterfaceNr
[0] = status
;
756 /* allocate instance-specific endpoints */
757 midi
->in_ep
= usb_ep_autoconfig(cdev
->gadget
, &bulk_in_desc
);
760 midi
->in_ep
->driver_data
= cdev
; /* claim */
762 midi
->out_ep
= usb_ep_autoconfig(cdev
->gadget
, &bulk_out_desc
);
765 midi
->out_ep
->driver_data
= cdev
; /* claim */
767 /* allocate temporary function list */
768 midi_function
= kcalloc((MAX_PORTS
* 4) + 9, sizeof(*midi_function
),
770 if (!midi_function
) {
776 * construct the function's descriptor set. As the number of
777 * input and output MIDI ports is configurable, we have to do
781 /* add the headers - these are always the same */
782 midi_function
[i
++] = (struct usb_descriptor_header
*) &ac_interface_desc
;
783 midi_function
[i
++] = (struct usb_descriptor_header
*) &ac_header_desc
;
784 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_interface_desc
;
786 /* calculate the header's wTotalLength */
787 n
= USB_DT_MS_HEADER_SIZE
788 + (midi
->in_ports
+ midi
->out_ports
) *
789 (USB_DT_MIDI_IN_SIZE
+ USB_DT_MIDI_OUT_SIZE(1));
790 ms_header_desc
.wTotalLength
= cpu_to_le16(n
);
792 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_header_desc
;
794 /* configure the external IN jacks, each linked to an embedded OUT jack */
795 for (n
= 0; n
< midi
->in_ports
; n
++) {
796 struct usb_midi_in_jack_descriptor
*in_ext
= &jack_in_ext_desc
[n
];
797 struct usb_midi_out_jack_descriptor_1
*out_emb
= &jack_out_emb_desc
[n
];
799 in_ext
->bLength
= USB_DT_MIDI_IN_SIZE
;
800 in_ext
->bDescriptorType
= USB_DT_CS_INTERFACE
;
801 in_ext
->bDescriptorSubtype
= USB_MS_MIDI_IN_JACK
;
802 in_ext
->bJackType
= USB_MS_EXTERNAL
;
803 in_ext
->bJackID
= jack
++;
805 midi_function
[i
++] = (struct usb_descriptor_header
*) in_ext
;
807 out_emb
->bLength
= USB_DT_MIDI_OUT_SIZE(1);
808 out_emb
->bDescriptorType
= USB_DT_CS_INTERFACE
;
809 out_emb
->bDescriptorSubtype
= USB_MS_MIDI_OUT_JACK
;
810 out_emb
->bJackType
= USB_MS_EMBEDDED
;
811 out_emb
->bJackID
= jack
++;
812 out_emb
->bNrInputPins
= 1;
813 out_emb
->pins
[0].baSourcePin
= 1;
814 out_emb
->pins
[0].baSourceID
= in_ext
->bJackID
;
816 midi_function
[i
++] = (struct usb_descriptor_header
*) out_emb
;
818 /* link it to the endpoint */
819 ms_in_desc
.baAssocJackID
[n
] = out_emb
->bJackID
;
822 /* configure the external OUT jacks, each linked to an embedded IN jack */
823 for (n
= 0; n
< midi
->out_ports
; n
++) {
824 struct usb_midi_in_jack_descriptor
*in_emb
= &jack_in_emb_desc
[n
];
825 struct usb_midi_out_jack_descriptor_1
*out_ext
= &jack_out_ext_desc
[n
];
827 in_emb
->bLength
= USB_DT_MIDI_IN_SIZE
;
828 in_emb
->bDescriptorType
= USB_DT_CS_INTERFACE
;
829 in_emb
->bDescriptorSubtype
= USB_MS_MIDI_IN_JACK
;
830 in_emb
->bJackType
= USB_MS_EMBEDDED
;
831 in_emb
->bJackID
= jack
++;
833 midi_function
[i
++] = (struct usb_descriptor_header
*) in_emb
;
835 out_ext
->bLength
= USB_DT_MIDI_OUT_SIZE(1);
836 out_ext
->bDescriptorType
= USB_DT_CS_INTERFACE
;
837 out_ext
->bDescriptorSubtype
= USB_MS_MIDI_OUT_JACK
;
838 out_ext
->bJackType
= USB_MS_EXTERNAL
;
839 out_ext
->bJackID
= jack
++;
840 out_ext
->bNrInputPins
= 1;
842 out_ext
->pins
[0].baSourceID
= in_emb
->bJackID
;
843 out_ext
->pins
[0].baSourcePin
= 1;
844 midi_function
[i
++] = (struct usb_descriptor_header
*) out_ext
;
846 /* link it to the endpoint */
847 ms_out_desc
.baAssocJackID
[n
] = in_emb
->bJackID
;
850 /* configure the endpoint descriptors ... */
851 ms_out_desc
.bLength
= USB_DT_MS_ENDPOINT_SIZE(midi
->in_ports
);
852 ms_out_desc
.bNumEmbMIDIJack
= midi
->in_ports
;
854 ms_in_desc
.bLength
= USB_DT_MS_ENDPOINT_SIZE(midi
->out_ports
);
855 ms_in_desc
.bNumEmbMIDIJack
= midi
->out_ports
;
857 /* ... and add them to the list */
858 midi_function
[i
++] = (struct usb_descriptor_header
*) &bulk_out_desc
;
859 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_out_desc
;
860 midi_function
[i
++] = (struct usb_descriptor_header
*) &bulk_in_desc
;
861 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_in_desc
;
862 midi_function
[i
++] = NULL
;
865 * support all relevant hardware speeds... we expect that when
866 * hardware is dual speed, all bulk-capable endpoints work at
869 /* copy descriptors, and track endpoint copies */
870 f
->fs_descriptors
= usb_copy_descriptors(midi_function
);
871 if (!f
->fs_descriptors
)
874 if (gadget_is_dualspeed(c
->cdev
->gadget
)) {
875 bulk_in_desc
.wMaxPacketSize
= cpu_to_le16(512);
876 bulk_out_desc
.wMaxPacketSize
= cpu_to_le16(512);
877 f
->hs_descriptors
= usb_copy_descriptors(midi_function
);
878 if (!f
->hs_descriptors
)
882 kfree(midi_function
);
887 kfree(midi_function
);
888 usb_free_descriptors(f
->hs_descriptors
);
890 f_midi_unregister_card(midi
);
892 /* we might as well release our claims on endpoints */
894 midi
->out_ep
->driver_data
= NULL
;
896 midi
->in_ep
->driver_data
= NULL
;
898 ERROR(cdev
, "%s: can't bind, err %d\n", f
->name
, status
);
903 static inline struct f_midi_opts
*to_f_midi_opts(struct config_item
*item
)
905 return container_of(to_config_group(item
), struct f_midi_opts
,
909 CONFIGFS_ATTR_STRUCT(f_midi_opts
);
910 CONFIGFS_ATTR_OPS(f_midi_opts
);
912 static void midi_attr_release(struct config_item
*item
)
914 struct f_midi_opts
*opts
= to_f_midi_opts(item
);
916 usb_put_function_instance(&opts
->func_inst
);
919 static struct configfs_item_operations midi_item_ops
= {
920 .release
= midi_attr_release
,
921 .show_attribute
= f_midi_opts_attr_show
,
922 .store_attribute
= f_midi_opts_attr_store
,
925 #define F_MIDI_OPT(name, test_limit, limit) \
926 static ssize_t f_midi_opts_##name##_show(struct f_midi_opts *opts, char *page) \
930 mutex_lock(&opts->lock); \
931 result = sprintf(page, "%d\n", opts->name); \
932 mutex_unlock(&opts->lock); \
937 static ssize_t f_midi_opts_##name##_store(struct f_midi_opts *opts, \
938 const char *page, size_t len) \
943 mutex_lock(&opts->lock); \
944 if (opts->refcnt) { \
949 ret = kstrtou32(page, 0, &num); \
953 if (test_limit && num > limit) { \
961 mutex_unlock(&opts->lock); \
965 static struct f_midi_opts_attribute f_midi_opts_##name = \
966 __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, f_midi_opts_##name##_show, \
967 f_midi_opts_##name##_store)
969 F_MIDI_OPT(index
, true, SNDRV_CARDS
);
970 F_MIDI_OPT(buflen
, false, 0);
971 F_MIDI_OPT(qlen
, false, 0);
972 F_MIDI_OPT(in_ports
, true, MAX_PORTS
);
973 F_MIDI_OPT(out_ports
, true, MAX_PORTS
);
975 static ssize_t
f_midi_opts_id_show(struct f_midi_opts
*opts
, char *page
)
979 mutex_lock(&opts
->lock
);
981 result
= strlcpy(page
, opts
->id
, PAGE_SIZE
);
987 mutex_unlock(&opts
->lock
);
992 static ssize_t
f_midi_opts_id_store(struct f_midi_opts
*opts
,
993 const char *page
, size_t len
)
998 mutex_lock(&opts
->lock
);
1004 c
= kstrndup(page
, len
, GFP_KERNEL
);
1009 if (opts
->id_allocated
)
1012 opts
->id_allocated
= true;
1015 mutex_unlock(&opts
->lock
);
1019 static struct f_midi_opts_attribute f_midi_opts_id
=
1020 __CONFIGFS_ATTR(id
, S_IRUGO
| S_IWUSR
, f_midi_opts_id_show
,
1021 f_midi_opts_id_store
);
1023 static struct configfs_attribute
*midi_attrs
[] = {
1024 &f_midi_opts_index
.attr
,
1025 &f_midi_opts_buflen
.attr
,
1026 &f_midi_opts_qlen
.attr
,
1027 &f_midi_opts_in_ports
.attr
,
1028 &f_midi_opts_out_ports
.attr
,
1029 &f_midi_opts_id
.attr
,
1033 static struct config_item_type midi_func_type
= {
1034 .ct_item_ops
= &midi_item_ops
,
1035 .ct_attrs
= midi_attrs
,
1036 .ct_owner
= THIS_MODULE
,
1039 static void f_midi_free_inst(struct usb_function_instance
*f
)
1041 struct f_midi_opts
*opts
;
1043 opts
= container_of(f
, struct f_midi_opts
, func_inst
);
1045 if (opts
->id_allocated
)
1051 static struct usb_function_instance
*f_midi_alloc_inst(void)
1053 struct f_midi_opts
*opts
;
1055 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
1057 return ERR_PTR(-ENOMEM
);
1059 mutex_init(&opts
->lock
);
1060 opts
->func_inst
.free_func_inst
= f_midi_free_inst
;
1061 opts
->index
= SNDRV_DEFAULT_IDX1
;
1062 opts
->id
= SNDRV_DEFAULT_STR1
;
1066 opts
->out_ports
= 1;
1068 config_group_init_type_name(&opts
->func_inst
.group
, "",
1071 return &opts
->func_inst
;
1074 static void f_midi_free(struct usb_function
*f
)
1076 struct f_midi
*midi
;
1077 struct f_midi_opts
*opts
;
1080 midi
= func_to_midi(f
);
1081 opts
= container_of(f
->fi
, struct f_midi_opts
, func_inst
);
1083 mutex_lock(&opts
->lock
);
1084 for (i
= opts
->in_ports
- 1; i
>= 0; --i
)
1085 kfree(midi
->in_port
[i
]);
1088 mutex_unlock(&opts
->lock
);
1091 static void f_midi_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
1093 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
1094 struct f_midi
*midi
= func_to_midi(f
);
1095 struct snd_card
*card
;
1097 DBG(cdev
, "unbind\n");
1099 /* just to be sure */
1105 snd_card_free(card
);
1107 usb_free_all_descriptors(f
);
1110 static struct usb_function
*f_midi_alloc(struct usb_function_instance
*fi
)
1112 struct f_midi
*midi
;
1113 struct f_midi_opts
*opts
;
1116 opts
= container_of(fi
, struct f_midi_opts
, func_inst
);
1118 mutex_lock(&opts
->lock
);
1120 if (opts
->in_ports
> MAX_PORTS
|| opts
->out_ports
> MAX_PORTS
) {
1121 mutex_unlock(&opts
->lock
);
1122 return ERR_PTR(-EINVAL
);
1125 /* allocate and initialize one new instance */
1126 midi
= kzalloc(sizeof(*midi
), GFP_KERNEL
);
1128 mutex_unlock(&opts
->lock
);
1129 return ERR_PTR(-ENOMEM
);
1132 for (i
= 0; i
< opts
->in_ports
; i
++) {
1133 struct gmidi_in_port
*port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
1137 mutex_unlock(&opts
->lock
);
1144 midi
->in_port
[i
] = port
;
1147 /* set up ALSA midi devices */
1148 midi
->id
= kstrdup(opts
->id
, GFP_KERNEL
);
1149 if (opts
->id
&& !midi
->id
) {
1151 mutex_unlock(&opts
->lock
);
1154 midi
->in_ports
= opts
->in_ports
;
1155 midi
->out_ports
= opts
->out_ports
;
1156 midi
->index
= opts
->index
;
1157 midi
->buflen
= opts
->buflen
;
1158 midi
->qlen
= opts
->qlen
;
1160 mutex_unlock(&opts
->lock
);
1162 midi
->func
.name
= "gmidi function";
1163 midi
->func
.bind
= f_midi_bind
;
1164 midi
->func
.unbind
= f_midi_unbind
;
1165 midi
->func
.set_alt
= f_midi_set_alt
;
1166 midi
->func
.disable
= f_midi_disable
;
1167 midi
->func
.free_func
= f_midi_free
;
1172 for (--i
; i
>= 0; i
--)
1173 kfree(midi
->in_port
[i
]);
1175 return ERR_PTR(status
);
1178 DECLARE_USB_FUNCTION_INIT(midi
, f_midi_alloc_inst
, f_midi_alloc
);