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
;
307 err
= config_ep_by_speed(midi
->gadget
, f
, ep
);
309 ERROR(cdev
, "can't configure %s: %d\n", ep
->name
, err
);
313 err
= usb_ep_enable(ep
);
315 ERROR(cdev
, "can't start %s: %d\n", ep
->name
, err
);
319 ep
->driver_data
= midi
;
324 static int f_midi_set_alt(struct usb_function
*f
, unsigned intf
, unsigned alt
)
326 struct f_midi
*midi
= func_to_midi(f
);
327 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
331 /* For Control Device interface we do nothing */
335 err
= f_midi_start_ep(midi
, f
, midi
->in_ep
);
339 err
= f_midi_start_ep(midi
, f
, midi
->out_ep
);
343 usb_ep_disable(midi
->out_ep
);
345 err
= config_ep_by_speed(midi
->gadget
, f
, midi
->out_ep
);
347 ERROR(cdev
, "can't configure %s: %d\n",
348 midi
->out_ep
->name
, err
);
352 err
= usb_ep_enable(midi
->out_ep
);
354 ERROR(cdev
, "can't start %s: %d\n",
355 midi
->out_ep
->name
, err
);
359 midi
->out_ep
->driver_data
= midi
;
361 /* allocate a bunch of read buffers and queue them all at once. */
362 for (i
= 0; i
< midi
->qlen
&& err
== 0; i
++) {
363 struct usb_request
*req
=
364 midi_alloc_ep_req(midi
->out_ep
, midi
->buflen
);
368 req
->complete
= f_midi_complete
;
369 err
= usb_ep_queue(midi
->out_ep
, req
, GFP_ATOMIC
);
371 ERROR(midi
, "%s queue req: %d\n",
372 midi
->out_ep
->name
, err
);
373 free_ep_req(midi
->out_ep
, req
);
380 static void f_midi_disable(struct usb_function
*f
)
382 struct f_midi
*midi
= func_to_midi(f
);
383 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
385 DBG(cdev
, "disable\n");
388 * just disable endpoints, forcing completion of pending i/o.
389 * all our completion handlers free their requests in this case.
391 usb_ep_disable(midi
->in_ep
);
392 usb_ep_disable(midi
->out_ep
);
395 static int f_midi_snd_free(struct snd_device
*device
)
400 static void f_midi_transmit_packet(struct usb_request
*req
, uint8_t p0
,
401 uint8_t p1
, uint8_t p2
, uint8_t p3
)
403 unsigned length
= req
->length
;
404 u8
*buf
= (u8
*)req
->buf
+ length
;
410 req
->length
= length
+ 4;
414 * Converts MIDI commands to USB MIDI packets.
416 static void f_midi_transmit_byte(struct usb_request
*req
,
417 struct gmidi_in_port
*port
, uint8_t b
)
419 uint8_t p0
= port
->cable
<< 4;
422 f_midi_transmit_packet(req
, p0
| 0x0f, b
, 0, 0);
423 } else if (b
>= 0xf0) {
427 port
->state
= STATE_SYSEX_1
;
432 port
->state
= STATE_1PARAM
;
436 port
->state
= STATE_2PARAM_1
;
440 port
->state
= STATE_UNKNOWN
;
443 f_midi_transmit_packet(req
, p0
| 0x05, 0xf6, 0, 0);
444 port
->state
= STATE_UNKNOWN
;
447 switch (port
->state
) {
449 f_midi_transmit_packet(req
,
450 p0
| 0x05, 0xf7, 0, 0);
453 f_midi_transmit_packet(req
,
454 p0
| 0x06, port
->data
[0], 0xf7, 0);
457 f_midi_transmit_packet(req
,
458 p0
| 0x07, port
->data
[0],
459 port
->data
[1], 0xf7);
462 port
->state
= STATE_UNKNOWN
;
465 } else if (b
>= 0x80) {
467 if (b
>= 0xc0 && b
<= 0xdf)
468 port
->state
= STATE_1PARAM
;
470 port
->state
= STATE_2PARAM_1
;
471 } else { /* b < 0x80 */
472 switch (port
->state
) {
474 if (port
->data
[0] < 0xf0) {
475 p0
|= port
->data
[0] >> 4;
478 port
->state
= STATE_UNKNOWN
;
480 f_midi_transmit_packet(req
, p0
, port
->data
[0], b
, 0);
484 port
->state
= STATE_2PARAM_2
;
487 if (port
->data
[0] < 0xf0) {
488 p0
|= port
->data
[0] >> 4;
489 port
->state
= STATE_2PARAM_1
;
492 port
->state
= STATE_UNKNOWN
;
494 f_midi_transmit_packet(req
,
495 p0
, port
->data
[0], port
->data
[1], b
);
499 port
->state
= STATE_SYSEX_1
;
503 port
->state
= STATE_SYSEX_2
;
506 f_midi_transmit_packet(req
,
507 p0
| 0x04, port
->data
[0], port
->data
[1], b
);
508 port
->state
= STATE_SYSEX_0
;
514 static void f_midi_transmit(struct f_midi
*midi
, struct usb_request
*req
)
516 struct usb_ep
*ep
= midi
->in_ep
;
523 req
= midi_alloc_ep_req(ep
, midi
->buflen
);
526 ERROR(midi
, "%s: alloc_ep_request failed\n", __func__
);
530 req
->complete
= f_midi_complete
;
532 for (i
= 0; i
< MAX_PORTS
; i
++) {
533 struct gmidi_in_port
*port
= midi
->in_port
[i
];
534 struct snd_rawmidi_substream
*substream
= midi
->in_substream
[i
];
536 if (!port
|| !port
->active
|| !substream
)
539 while (req
->length
+ 3 < midi
->buflen
) {
541 if (snd_rawmidi_transmit(substream
, &b
, 1) != 1) {
545 f_midi_transmit_byte(req
, port
, b
);
549 if (req
->length
> 0 && ep
->enabled
) {
552 err
= usb_ep_queue(ep
, req
, GFP_ATOMIC
);
554 ERROR(midi
, "%s queue req: %d\n",
555 midi
->in_ep
->name
, err
);
557 free_ep_req(ep
, req
);
561 static void f_midi_in_tasklet(unsigned long data
)
563 struct f_midi
*midi
= (struct f_midi
*) data
;
564 f_midi_transmit(midi
, NULL
);
567 static int f_midi_in_open(struct snd_rawmidi_substream
*substream
)
569 struct f_midi
*midi
= substream
->rmidi
->private_data
;
571 if (!midi
->in_port
[substream
->number
])
574 VDBG(midi
, "%s()\n", __func__
);
575 midi
->in_substream
[substream
->number
] = substream
;
576 midi
->in_port
[substream
->number
]->state
= STATE_UNKNOWN
;
580 static int f_midi_in_close(struct snd_rawmidi_substream
*substream
)
582 struct f_midi
*midi
= substream
->rmidi
->private_data
;
584 VDBG(midi
, "%s()\n", __func__
);
588 static void f_midi_in_trigger(struct snd_rawmidi_substream
*substream
, int up
)
590 struct f_midi
*midi
= substream
->rmidi
->private_data
;
592 if (!midi
->in_port
[substream
->number
])
595 VDBG(midi
, "%s() %d\n", __func__
, up
);
596 midi
->in_port
[substream
->number
]->active
= up
;
598 tasklet_hi_schedule(&midi
->tasklet
);
601 static int f_midi_out_open(struct snd_rawmidi_substream
*substream
)
603 struct f_midi
*midi
= substream
->rmidi
->private_data
;
605 if (substream
->number
>= MAX_PORTS
)
608 VDBG(midi
, "%s()\n", __func__
);
609 midi
->out_substream
[substream
->number
] = substream
;
613 static int f_midi_out_close(struct snd_rawmidi_substream
*substream
)
615 struct f_midi
*midi
= substream
->rmidi
->private_data
;
617 VDBG(midi
, "%s()\n", __func__
);
621 static void f_midi_out_trigger(struct snd_rawmidi_substream
*substream
, int up
)
623 struct f_midi
*midi
= substream
->rmidi
->private_data
;
625 VDBG(midi
, "%s()\n", __func__
);
628 set_bit(substream
->number
, &midi
->out_triggered
);
630 clear_bit(substream
->number
, &midi
->out_triggered
);
633 static struct snd_rawmidi_ops gmidi_in_ops
= {
634 .open
= f_midi_in_open
,
635 .close
= f_midi_in_close
,
636 .trigger
= f_midi_in_trigger
,
639 static struct snd_rawmidi_ops gmidi_out_ops
= {
640 .open
= f_midi_out_open
,
641 .close
= f_midi_out_close
,
642 .trigger
= f_midi_out_trigger
645 static inline void f_midi_unregister_card(struct f_midi
*midi
)
648 snd_card_free(midi
->card
);
653 /* register as a sound "card" */
654 static int f_midi_register_card(struct f_midi
*midi
)
656 struct snd_card
*card
;
657 struct snd_rawmidi
*rmidi
;
659 static struct snd_device_ops ops
= {
660 .dev_free
= f_midi_snd_free
,
663 err
= snd_card_new(&midi
->gadget
->dev
, midi
->index
, midi
->id
,
664 THIS_MODULE
, 0, &card
);
666 ERROR(midi
, "snd_card_new() failed\n");
671 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, midi
, &ops
);
673 ERROR(midi
, "snd_device_new() failed: error %d\n", err
);
677 strcpy(card
->driver
, f_midi_longname
);
678 strcpy(card
->longname
, f_midi_longname
);
679 strcpy(card
->shortname
, f_midi_shortname
);
682 snd_component_add(card
, "MIDI");
683 err
= snd_rawmidi_new(card
, card
->longname
, 0,
684 midi
->out_ports
, midi
->in_ports
, &rmidi
);
686 ERROR(midi
, "snd_rawmidi_new() failed: error %d\n", err
);
690 strcpy(rmidi
->name
, card
->shortname
);
691 rmidi
->info_flags
= SNDRV_RAWMIDI_INFO_OUTPUT
|
692 SNDRV_RAWMIDI_INFO_INPUT
|
693 SNDRV_RAWMIDI_INFO_DUPLEX
;
694 rmidi
->private_data
= midi
;
697 * Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT.
698 * It's an upside-down world being a gadget.
700 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
, &gmidi_in_ops
);
701 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
, &gmidi_out_ops
);
703 /* register it - we're ready to go */
704 err
= snd_card_register(card
);
706 ERROR(midi
, "snd_card_register() failed\n");
710 VDBG(midi
, "%s() finished ok\n", __func__
);
714 f_midi_unregister_card(midi
);
718 /* MIDI function driver setup/binding */
720 static int f_midi_bind(struct usb_configuration
*c
, struct usb_function
*f
)
722 struct usb_descriptor_header
**midi_function
;
723 struct usb_midi_in_jack_descriptor jack_in_ext_desc
[MAX_PORTS
];
724 struct usb_midi_in_jack_descriptor jack_in_emb_desc
[MAX_PORTS
];
725 struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc
[MAX_PORTS
];
726 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc
[MAX_PORTS
];
727 struct usb_composite_dev
*cdev
= c
->cdev
;
728 struct f_midi
*midi
= func_to_midi(f
);
729 struct usb_string
*us
;
730 int status
, n
, jack
= 1, i
= 0;
732 midi
->gadget
= cdev
->gadget
;
733 tasklet_init(&midi
->tasklet
, f_midi_in_tasklet
, (unsigned long) midi
);
734 status
= f_midi_register_card(midi
);
738 /* maybe allocate device-global string ID */
739 us
= usb_gstrings_attach(c
->cdev
, midi_strings
,
740 ARRAY_SIZE(midi_string_defs
));
742 status
= PTR_ERR(us
);
745 ac_interface_desc
.iInterface
= us
[STRING_FUNC_IDX
].id
;
747 /* We have two interfaces, AudioControl and MIDIStreaming */
748 status
= usb_interface_id(c
, f
);
751 ac_interface_desc
.bInterfaceNumber
= status
;
753 status
= usb_interface_id(c
, f
);
756 ms_interface_desc
.bInterfaceNumber
= status
;
757 ac_header_desc
.baInterfaceNr
[0] = status
;
761 /* allocate instance-specific endpoints */
762 midi
->in_ep
= usb_ep_autoconfig(cdev
->gadget
, &bulk_in_desc
);
766 midi
->out_ep
= usb_ep_autoconfig(cdev
->gadget
, &bulk_out_desc
);
770 /* allocate temporary function list */
771 midi_function
= kcalloc((MAX_PORTS
* 4) + 9, sizeof(*midi_function
),
773 if (!midi_function
) {
779 * construct the function's descriptor set. As the number of
780 * input and output MIDI ports is configurable, we have to do
784 /* add the headers - these are always the same */
785 midi_function
[i
++] = (struct usb_descriptor_header
*) &ac_interface_desc
;
786 midi_function
[i
++] = (struct usb_descriptor_header
*) &ac_header_desc
;
787 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_interface_desc
;
789 /* calculate the header's wTotalLength */
790 n
= USB_DT_MS_HEADER_SIZE
791 + (midi
->in_ports
+ midi
->out_ports
) *
792 (USB_DT_MIDI_IN_SIZE
+ USB_DT_MIDI_OUT_SIZE(1));
793 ms_header_desc
.wTotalLength
= cpu_to_le16(n
);
795 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_header_desc
;
797 /* configure the external IN jacks, each linked to an embedded OUT jack */
798 for (n
= 0; n
< midi
->in_ports
; n
++) {
799 struct usb_midi_in_jack_descriptor
*in_ext
= &jack_in_ext_desc
[n
];
800 struct usb_midi_out_jack_descriptor_1
*out_emb
= &jack_out_emb_desc
[n
];
802 in_ext
->bLength
= USB_DT_MIDI_IN_SIZE
;
803 in_ext
->bDescriptorType
= USB_DT_CS_INTERFACE
;
804 in_ext
->bDescriptorSubtype
= USB_MS_MIDI_IN_JACK
;
805 in_ext
->bJackType
= USB_MS_EXTERNAL
;
806 in_ext
->bJackID
= jack
++;
808 midi_function
[i
++] = (struct usb_descriptor_header
*) in_ext
;
810 out_emb
->bLength
= USB_DT_MIDI_OUT_SIZE(1);
811 out_emb
->bDescriptorType
= USB_DT_CS_INTERFACE
;
812 out_emb
->bDescriptorSubtype
= USB_MS_MIDI_OUT_JACK
;
813 out_emb
->bJackType
= USB_MS_EMBEDDED
;
814 out_emb
->bJackID
= jack
++;
815 out_emb
->bNrInputPins
= 1;
816 out_emb
->pins
[0].baSourcePin
= 1;
817 out_emb
->pins
[0].baSourceID
= in_ext
->bJackID
;
819 midi_function
[i
++] = (struct usb_descriptor_header
*) out_emb
;
821 /* link it to the endpoint */
822 ms_in_desc
.baAssocJackID
[n
] = out_emb
->bJackID
;
825 /* configure the external OUT jacks, each linked to an embedded IN jack */
826 for (n
= 0; n
< midi
->out_ports
; n
++) {
827 struct usb_midi_in_jack_descriptor
*in_emb
= &jack_in_emb_desc
[n
];
828 struct usb_midi_out_jack_descriptor_1
*out_ext
= &jack_out_ext_desc
[n
];
830 in_emb
->bLength
= USB_DT_MIDI_IN_SIZE
;
831 in_emb
->bDescriptorType
= USB_DT_CS_INTERFACE
;
832 in_emb
->bDescriptorSubtype
= USB_MS_MIDI_IN_JACK
;
833 in_emb
->bJackType
= USB_MS_EMBEDDED
;
834 in_emb
->bJackID
= jack
++;
836 midi_function
[i
++] = (struct usb_descriptor_header
*) in_emb
;
838 out_ext
->bLength
= USB_DT_MIDI_OUT_SIZE(1);
839 out_ext
->bDescriptorType
= USB_DT_CS_INTERFACE
;
840 out_ext
->bDescriptorSubtype
= USB_MS_MIDI_OUT_JACK
;
841 out_ext
->bJackType
= USB_MS_EXTERNAL
;
842 out_ext
->bJackID
= jack
++;
843 out_ext
->bNrInputPins
= 1;
845 out_ext
->pins
[0].baSourceID
= in_emb
->bJackID
;
846 out_ext
->pins
[0].baSourcePin
= 1;
847 midi_function
[i
++] = (struct usb_descriptor_header
*) out_ext
;
849 /* link it to the endpoint */
850 ms_out_desc
.baAssocJackID
[n
] = in_emb
->bJackID
;
853 /* configure the endpoint descriptors ... */
854 ms_out_desc
.bLength
= USB_DT_MS_ENDPOINT_SIZE(midi
->in_ports
);
855 ms_out_desc
.bNumEmbMIDIJack
= midi
->in_ports
;
857 ms_in_desc
.bLength
= USB_DT_MS_ENDPOINT_SIZE(midi
->out_ports
);
858 ms_in_desc
.bNumEmbMIDIJack
= midi
->out_ports
;
860 /* ... and add them to the list */
861 midi_function
[i
++] = (struct usb_descriptor_header
*) &bulk_out_desc
;
862 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_out_desc
;
863 midi_function
[i
++] = (struct usb_descriptor_header
*) &bulk_in_desc
;
864 midi_function
[i
++] = (struct usb_descriptor_header
*) &ms_in_desc
;
865 midi_function
[i
++] = NULL
;
868 * support all relevant hardware speeds... we expect that when
869 * hardware is dual speed, all bulk-capable endpoints work at
872 /* copy descriptors, and track endpoint copies */
873 f
->fs_descriptors
= usb_copy_descriptors(midi_function
);
874 if (!f
->fs_descriptors
)
877 if (gadget_is_dualspeed(c
->cdev
->gadget
)) {
878 bulk_in_desc
.wMaxPacketSize
= cpu_to_le16(512);
879 bulk_out_desc
.wMaxPacketSize
= cpu_to_le16(512);
880 f
->hs_descriptors
= usb_copy_descriptors(midi_function
);
881 if (!f
->hs_descriptors
)
885 kfree(midi_function
);
890 kfree(midi_function
);
891 usb_free_descriptors(f
->hs_descriptors
);
893 f_midi_unregister_card(midi
);
895 ERROR(cdev
, "%s: can't bind, err %d\n", f
->name
, status
);
900 static inline struct f_midi_opts
*to_f_midi_opts(struct config_item
*item
)
902 return container_of(to_config_group(item
), struct f_midi_opts
,
906 static void midi_attr_release(struct config_item
*item
)
908 struct f_midi_opts
*opts
= to_f_midi_opts(item
);
910 usb_put_function_instance(&opts
->func_inst
);
913 static struct configfs_item_operations midi_item_ops
= {
914 .release
= midi_attr_release
,
917 #define F_MIDI_OPT(name, test_limit, limit) \
918 static ssize_t f_midi_opts_##name##_show(struct config_item *item, char *page) \
920 struct f_midi_opts *opts = to_f_midi_opts(item); \
923 mutex_lock(&opts->lock); \
924 result = sprintf(page, "%d\n", opts->name); \
925 mutex_unlock(&opts->lock); \
930 static ssize_t f_midi_opts_##name##_store(struct config_item *item, \
931 const char *page, size_t len) \
933 struct f_midi_opts *opts = to_f_midi_opts(item); \
937 mutex_lock(&opts->lock); \
938 if (opts->refcnt) { \
943 ret = kstrtou32(page, 0, &num); \
947 if (test_limit && num > limit) { \
955 mutex_unlock(&opts->lock); \
959 CONFIGFS_ATTR(f_midi_opts_, name);
961 F_MIDI_OPT(index
, true, SNDRV_CARDS
);
962 F_MIDI_OPT(buflen
, false, 0);
963 F_MIDI_OPT(qlen
, false, 0);
964 F_MIDI_OPT(in_ports
, true, MAX_PORTS
);
965 F_MIDI_OPT(out_ports
, true, MAX_PORTS
);
967 static ssize_t
f_midi_opts_id_show(struct config_item
*item
, char *page
)
969 struct f_midi_opts
*opts
= to_f_midi_opts(item
);
972 mutex_lock(&opts
->lock
);
974 result
= strlcpy(page
, opts
->id
, PAGE_SIZE
);
980 mutex_unlock(&opts
->lock
);
985 static ssize_t
f_midi_opts_id_store(struct config_item
*item
,
986 const char *page
, size_t len
)
988 struct f_midi_opts
*opts
= to_f_midi_opts(item
);
992 mutex_lock(&opts
->lock
);
998 c
= kstrndup(page
, len
, GFP_KERNEL
);
1003 if (opts
->id_allocated
)
1006 opts
->id_allocated
= true;
1009 mutex_unlock(&opts
->lock
);
1013 CONFIGFS_ATTR(f_midi_opts_
, id
);
1015 static struct configfs_attribute
*midi_attrs
[] = {
1016 &f_midi_opts_attr_index
,
1017 &f_midi_opts_attr_buflen
,
1018 &f_midi_opts_attr_qlen
,
1019 &f_midi_opts_attr_in_ports
,
1020 &f_midi_opts_attr_out_ports
,
1021 &f_midi_opts_attr_id
,
1025 static struct config_item_type midi_func_type
= {
1026 .ct_item_ops
= &midi_item_ops
,
1027 .ct_attrs
= midi_attrs
,
1028 .ct_owner
= THIS_MODULE
,
1031 static void f_midi_free_inst(struct usb_function_instance
*f
)
1033 struct f_midi_opts
*opts
;
1035 opts
= container_of(f
, struct f_midi_opts
, func_inst
);
1037 if (opts
->id_allocated
)
1043 static struct usb_function_instance
*f_midi_alloc_inst(void)
1045 struct f_midi_opts
*opts
;
1047 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
1049 return ERR_PTR(-ENOMEM
);
1051 mutex_init(&opts
->lock
);
1052 opts
->func_inst
.free_func_inst
= f_midi_free_inst
;
1053 opts
->index
= SNDRV_DEFAULT_IDX1
;
1054 opts
->id
= SNDRV_DEFAULT_STR1
;
1058 opts
->out_ports
= 1;
1060 config_group_init_type_name(&opts
->func_inst
.group
, "",
1063 return &opts
->func_inst
;
1066 static void f_midi_free(struct usb_function
*f
)
1068 struct f_midi
*midi
;
1069 struct f_midi_opts
*opts
;
1072 midi
= func_to_midi(f
);
1073 opts
= container_of(f
->fi
, struct f_midi_opts
, func_inst
);
1075 mutex_lock(&opts
->lock
);
1076 for (i
= opts
->in_ports
- 1; i
>= 0; --i
)
1077 kfree(midi
->in_port
[i
]);
1080 mutex_unlock(&opts
->lock
);
1083 static void f_midi_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
1085 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
1086 struct f_midi
*midi
= func_to_midi(f
);
1087 struct snd_card
*card
;
1089 DBG(cdev
, "unbind\n");
1091 /* just to be sure */
1097 snd_card_free(card
);
1099 usb_free_all_descriptors(f
);
1102 static struct usb_function
*f_midi_alloc(struct usb_function_instance
*fi
)
1104 struct f_midi
*midi
;
1105 struct f_midi_opts
*opts
;
1108 opts
= container_of(fi
, struct f_midi_opts
, func_inst
);
1110 mutex_lock(&opts
->lock
);
1112 if (opts
->in_ports
> MAX_PORTS
|| opts
->out_ports
> MAX_PORTS
) {
1113 mutex_unlock(&opts
->lock
);
1114 return ERR_PTR(-EINVAL
);
1117 /* allocate and initialize one new instance */
1118 midi
= kzalloc(sizeof(*midi
), GFP_KERNEL
);
1120 mutex_unlock(&opts
->lock
);
1121 return ERR_PTR(-ENOMEM
);
1124 for (i
= 0; i
< opts
->in_ports
; i
++) {
1125 struct gmidi_in_port
*port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
1129 mutex_unlock(&opts
->lock
);
1136 midi
->in_port
[i
] = port
;
1139 /* set up ALSA midi devices */
1140 midi
->id
= kstrdup(opts
->id
, GFP_KERNEL
);
1141 if (opts
->id
&& !midi
->id
) {
1143 mutex_unlock(&opts
->lock
);
1146 midi
->in_ports
= opts
->in_ports
;
1147 midi
->out_ports
= opts
->out_ports
;
1148 midi
->index
= opts
->index
;
1149 midi
->buflen
= opts
->buflen
;
1150 midi
->qlen
= opts
->qlen
;
1152 mutex_unlock(&opts
->lock
);
1154 midi
->func
.name
= "gmidi function";
1155 midi
->func
.bind
= f_midi_bind
;
1156 midi
->func
.unbind
= f_midi_unbind
;
1157 midi
->func
.set_alt
= f_midi_set_alt
;
1158 midi
->func
.disable
= f_midi_disable
;
1159 midi
->func
.free_func
= f_midi_free
;
1164 for (--i
; i
>= 0; i
--)
1165 kfree(midi
->in_port
[i
]);
1167 return ERR_PTR(status
);
1170 DECLARE_USB_FUNCTION_INIT(midi
, f_midi_alloc_inst
, f_midi_alloc
);