aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/gadget/f_midi.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/gadget/f_midi.c')
-rw-r--r--drivers/usb/gadget/f_midi.c990
1 files changed, 990 insertions, 0 deletions
diff --git a/drivers/usb/gadget/f_midi.c b/drivers/usb/gadget/f_midi.c
new file mode 100644
index 000000000000..3797b3d6c622
--- /dev/null
+++ b/drivers/usb/gadget/f_midi.c
@@ -0,0 +1,990 @@
1/*
2 * f_midi.c -- USB MIDI class function driver
3 *
4 * Copyright (C) 2006 Thumtronics Pty Ltd.
5 * Developed for Thumtronics by Grey Innovation
6 * Ben Williamson <ben.williamson@greyinnovation.com>
7 *
8 * Rewritten for the composite framework
9 * Copyright (C) 2011 Daniel Mack <zonque@gmail.com>
10 *
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
14 *
15 * and drivers/usb/gadget/midi.c,
16 * Copyright (C) 2006 Thumtronics Pty Ltd.
17 * Ben Williamson <ben.williamson@greyinnovation.com>
18 *
19 * Licensed under the GPL-2 or later.
20 */
21
22#include <linux/kernel.h>
23#include <linux/slab.h>
24#include <linux/utsname.h>
25#include <linux/device.h>
26
27#include <sound/core.h>
28#include <sound/initval.h>
29#include <sound/rawmidi.h>
30
31#include <linux/usb/ch9.h>
32#include <linux/usb/gadget.h>
33#include <linux/usb/audio.h>
34#include <linux/usb/midi.h>
35
36MODULE_AUTHOR("Ben Williamson");
37MODULE_LICENSE("GPL v2");
38
39static const char f_midi_shortname[] = "f_midi";
40static const char f_midi_longname[] = "MIDI Gadget";
41
42/*
43 * We can only handle 16 cables on one single endpoint, as cable numbers are
44 * stored in 4-bit fields. And as the interface currently only holds one
45 * single endpoint, this is the maximum number of ports we can allow.
46 */
47#define MAX_PORTS 16
48
49/*
50 * This is a gadget, and the IN/OUT naming is from the host's perspective.
51 * USB -> OUT endpoint -> rawmidi
52 * USB <- IN endpoint <- rawmidi
53 */
54struct gmidi_in_port {
55 struct f_midi *midi;
56 int active;
57 uint8_t cable;
58 uint8_t state;
59#define STATE_UNKNOWN 0
60#define STATE_1PARAM 1
61#define STATE_2PARAM_1 2
62#define STATE_2PARAM_2 3
63#define STATE_SYSEX_0 4
64#define STATE_SYSEX_1 5
65#define STATE_SYSEX_2 6
66 uint8_t data[2];
67};
68
69struct f_midi {
70 struct usb_function func;
71 struct usb_gadget *gadget;
72 struct usb_ep *in_ep, *out_ep;
73 struct snd_card *card;
74 struct snd_rawmidi *rmidi;
75
76 struct snd_rawmidi_substream *in_substream[MAX_PORTS];
77 struct snd_rawmidi_substream *out_substream[MAX_PORTS];
78 struct gmidi_in_port *in_port[MAX_PORTS];
79
80 unsigned long out_triggered;
81 struct tasklet_struct tasklet;
82 unsigned int in_ports;
83 unsigned int out_ports;
84 int index;
85 char *id;
86 unsigned int buflen, qlen;
87};
88
89static inline struct f_midi *func_to_midi(struct usb_function *f)
90{
91 return container_of(f, struct f_midi, func);
92}
93
94static void f_midi_transmit(struct f_midi *midi, struct usb_request *req);
95
96DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
97DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
98DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
99
100/* B.3.1 Standard AC Interface Descriptor */
101static struct usb_interface_descriptor ac_interface_desc __initdata = {
102 .bLength = USB_DT_INTERFACE_SIZE,
103 .bDescriptorType = USB_DT_INTERFACE,
104 /* .bInterfaceNumber = DYNAMIC */
105 /* .bNumEndpoints = DYNAMIC */
106 .bInterfaceClass = USB_CLASS_AUDIO,
107 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
108 /* .iInterface = DYNAMIC */
109};
110
111/* B.3.2 Class-Specific AC Interface Descriptor */
112static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = {
113 .bLength = UAC_DT_AC_HEADER_SIZE(1),
114 .bDescriptorType = USB_DT_CS_INTERFACE,
115 .bDescriptorSubtype = USB_MS_HEADER,
116 .bcdADC = cpu_to_le16(0x0100),
117 .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
118 .bInCollection = 1,
119 /* .baInterfaceNr = DYNAMIC */
120};
121
122/* B.4.1 Standard MS Interface Descriptor */
123static struct usb_interface_descriptor ms_interface_desc __initdata = {
124 .bLength = USB_DT_INTERFACE_SIZE,
125 .bDescriptorType = USB_DT_INTERFACE,
126 /* .bInterfaceNumber = DYNAMIC */
127 .bNumEndpoints = 2,
128 .bInterfaceClass = USB_CLASS_AUDIO,
129 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
130 /* .iInterface = DYNAMIC */
131};
132
133/* B.4.2 Class-Specific MS Interface Descriptor */
134static struct usb_ms_header_descriptor ms_header_desc __initdata = {
135 .bLength = USB_DT_MS_HEADER_SIZE,
136 .bDescriptorType = USB_DT_CS_INTERFACE,
137 .bDescriptorSubtype = USB_MS_HEADER,
138 .bcdMSC = cpu_to_le16(0x0100),
139 /* .wTotalLength = DYNAMIC */
140};
141
142/* B.5.1 Standard Bulk OUT Endpoint Descriptor */
143static struct usb_endpoint_descriptor bulk_out_desc = {
144 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
145 .bDescriptorType = USB_DT_ENDPOINT,
146 .bEndpointAddress = USB_DIR_OUT,
147 .bmAttributes = USB_ENDPOINT_XFER_BULK,
148};
149
150/* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */
151static struct usb_ms_endpoint_descriptor_16 ms_out_desc = {
152 /* .bLength = DYNAMIC */
153 .bDescriptorType = USB_DT_CS_ENDPOINT,
154 .bDescriptorSubtype = USB_MS_GENERAL,
155 /* .bNumEmbMIDIJack = DYNAMIC */
156 /* .baAssocJackID = DYNAMIC */
157};
158
159/* B.6.1 Standard Bulk IN Endpoint Descriptor */
160static struct usb_endpoint_descriptor bulk_in_desc = {
161 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
162 .bDescriptorType = USB_DT_ENDPOINT,
163 .bEndpointAddress = USB_DIR_IN,
164 .bmAttributes = USB_ENDPOINT_XFER_BULK,
165};
166
167/* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */
168static struct usb_ms_endpoint_descriptor_16 ms_in_desc = {
169 /* .bLength = DYNAMIC */
170 .bDescriptorType = USB_DT_CS_ENDPOINT,
171 .bDescriptorSubtype = USB_MS_GENERAL,
172 /* .bNumEmbMIDIJack = DYNAMIC */
173 /* .baAssocJackID = DYNAMIC */
174};
175
176/* string IDs are assigned dynamically */
177
178#define STRING_FUNC_IDX 0
179
180static struct usb_string midi_string_defs[] = {
181 [STRING_FUNC_IDX].s = "MIDI function",
182 { } /* end of list */
183};
184
185static struct usb_gadget_strings midi_stringtab = {
186 .language = 0x0409, /* en-us */
187 .strings = midi_string_defs,
188};
189
190static struct usb_gadget_strings *midi_strings[] = {
191 &midi_stringtab,
192 NULL,
193};
194
195static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
196{
197 struct usb_request *req;
198
199 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
200 if (req) {
201 req->length = length;
202 req->buf = kmalloc(length, GFP_ATOMIC);
203 if (!req->buf) {
204 usb_ep_free_request(ep, req);
205 req = NULL;
206 }
207 }
208 return req;
209}
210
211static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
212{
213 kfree(req->buf);
214 usb_ep_free_request(ep, req);
215}
216
217static const uint8_t f_midi_cin_length[] = {
218 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
219};
220
221/*
222 * Receives a chunk of MIDI data.
223 */
224static void f_midi_read_data(struct usb_ep *ep, int cable,
225 uint8_t *data, int length)
226{
227 struct f_midi *midi = ep->driver_data;
228 struct snd_rawmidi_substream *substream = midi->out_substream[cable];
229
230 if (!substream)
231 /* Nobody is listening - throw it on the floor. */
232 return;
233
234 if (!test_bit(cable, &midi->out_triggered))
235 return;
236
237 snd_rawmidi_receive(substream, data, length);
238}
239
240static void f_midi_handle_out_data(struct usb_ep *ep, struct usb_request *req)
241{
242 unsigned int i;
243 u8 *buf = req->buf;
244
245 for (i = 0; i + 3 < req->actual; i += 4)
246 if (buf[i] != 0) {
247 int cable = buf[i] >> 4;
248 int length = f_midi_cin_length[buf[i] & 0x0f];
249 f_midi_read_data(ep, cable, &buf[i + 1], length);
250 }
251}
252
253static void
254f_midi_complete(struct usb_ep *ep, struct usb_request *req)
255{
256 struct f_midi *midi = ep->driver_data;
257 struct usb_composite_dev *cdev = midi->func.config->cdev;
258 int status = req->status;
259
260 switch (status) {
261 case 0: /* normal completion */
262 if (ep == midi->out_ep) {
263 /* We received stuff. req is queued again, below */
264 f_midi_handle_out_data(ep, req);
265 } else if (ep == midi->in_ep) {
266 /* Our transmit completed. See if there's more to go.
267 * f_midi_transmit eats req, don't queue it again. */
268 f_midi_transmit(midi, req);
269 return;
270 }
271 break;
272
273 /* this endpoint is normally active while we're configured */
274 case -ECONNABORTED: /* hardware forced ep reset */
275 case -ECONNRESET: /* request dequeued */
276 case -ESHUTDOWN: /* disconnect from host */
277 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
278 req->actual, req->length);
279 if (ep == midi->out_ep)
280 f_midi_handle_out_data(ep, req);
281
282 free_ep_req(ep, req);
283 return;
284
285 case -EOVERFLOW: /* buffer overrun on read means that
286 * we didn't provide a big enough buffer.
287 */
288 default:
289 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
290 status, req->actual, req->length);
291 break;
292 case -EREMOTEIO: /* short read */
293 break;
294 }
295
296 status = usb_ep_queue(ep, req, GFP_ATOMIC);
297 if (status) {
298 ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n",
299 ep->name, req->length, status);
300 usb_ep_set_halt(ep);
301 /* FIXME recover later ... somehow */
302 }
303}
304
305static int f_midi_start_ep(struct f_midi *midi,
306 struct usb_function *f,
307 struct usb_ep *ep)
308{
309 int err;
310 struct usb_composite_dev *cdev = f->config->cdev;
311
312 if (ep->driver_data)
313 usb_ep_disable(ep);
314
315 err = config_ep_by_speed(midi->gadget, f, ep);
316 if (err) {
317 ERROR(cdev, "can't configure %s: %d\n", ep->name, err);
318 return err;
319 }
320
321 err = usb_ep_enable(ep);
322 if (err) {
323 ERROR(cdev, "can't start %s: %d\n", ep->name, err);
324 return err;
325 }
326
327 ep->driver_data = midi;
328
329 return 0;
330}
331
332static int f_midi_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
333{
334 struct f_midi *midi = func_to_midi(f);
335 struct usb_composite_dev *cdev = f->config->cdev;
336 unsigned i;
337 int err;
338
339 err = f_midi_start_ep(midi, f, midi->in_ep);
340 if (err)
341 return err;
342
343 err = f_midi_start_ep(midi, f, midi->out_ep);
344 if (err)
345 return err;
346
347 if (midi->out_ep->driver_data)
348 usb_ep_disable(midi->out_ep);
349
350 err = config_ep_by_speed(midi->gadget, f, midi->out_ep);
351 if (err) {
352 ERROR(cdev, "can't configure %s: %d\n",
353 midi->out_ep->name, err);
354 return err;
355 }
356
357 err = usb_ep_enable(midi->out_ep);
358 if (err) {
359 ERROR(cdev, "can't start %s: %d\n",
360 midi->out_ep->name, err);
361 return err;
362 }
363
364 midi->out_ep->driver_data = midi;
365
366 /* allocate a bunch of read buffers and queue them all at once. */
367 for (i = 0; i < midi->qlen && err == 0; i++) {
368 struct usb_request *req =
369 alloc_ep_req(midi->out_ep, midi->buflen);
370 if (req == NULL)
371 return -ENOMEM;
372
373 req->complete = f_midi_complete;
374 err = usb_ep_queue(midi->out_ep, req, GFP_ATOMIC);
375 if (err) {
376 ERROR(midi, "%s queue req: %d\n",
377 midi->out_ep->name, err);
378 }
379 }
380
381 return 0;
382}
383
384static void f_midi_disable(struct usb_function *f)
385{
386 struct f_midi *midi = func_to_midi(f);
387 struct usb_composite_dev *cdev = f->config->cdev;
388
389 DBG(cdev, "disable\n");
390
391 /*
392 * just disable endpoints, forcing completion of pending i/o.
393 * all our completion handlers free their requests in this case.
394 */
395 usb_ep_disable(midi->in_ep);
396 usb_ep_disable(midi->out_ep);
397}
398
399static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
400{
401 struct usb_composite_dev *cdev = f->config->cdev;
402 struct f_midi *midi = func_to_midi(f);
403 struct snd_card *card;
404
405 DBG(cdev, "unbind\n");
406
407 /* just to be sure */
408 f_midi_disable(f);
409
410 card = midi->card;
411 midi->card = NULL;
412 if (card)
413 snd_card_free(card);
414
415 kfree(midi->id);
416 midi->id = NULL;
417
418 usb_free_descriptors(f->descriptors);
419 kfree(midi);
420}
421
422static int f_midi_snd_free(struct snd_device *device)
423{
424 return 0;
425}
426
427static void f_midi_transmit_packet(struct usb_request *req, uint8_t p0,
428 uint8_t p1, uint8_t p2, uint8_t p3)
429{
430 unsigned length = req->length;
431 u8 *buf = (u8 *)req->buf + length;
432
433 buf[0] = p0;
434 buf[1] = p1;
435 buf[2] = p2;
436 buf[3] = p3;
437 req->length = length + 4;
438}
439
440/*
441 * Converts MIDI commands to USB MIDI packets.
442 */
443static void f_midi_transmit_byte(struct usb_request *req,
444 struct gmidi_in_port *port, uint8_t b)
445{
446 uint8_t p0 = port->cable << 4;
447
448 if (b >= 0xf8) {
449 f_midi_transmit_packet(req, p0 | 0x0f, b, 0, 0);
450 } else if (b >= 0xf0) {
451 switch (b) {
452 case 0xf0:
453 port->data[0] = b;
454 port->state = STATE_SYSEX_1;
455 break;
456 case 0xf1:
457 case 0xf3:
458 port->data[0] = b;
459 port->state = STATE_1PARAM;
460 break;
461 case 0xf2:
462 port->data[0] = b;
463 port->state = STATE_2PARAM_1;
464 break;
465 case 0xf4:
466 case 0xf5:
467 port->state = STATE_UNKNOWN;
468 break;
469 case 0xf6:
470 f_midi_transmit_packet(req, p0 | 0x05, 0xf6, 0, 0);
471 port->state = STATE_UNKNOWN;
472 break;
473 case 0xf7:
474 switch (port->state) {
475 case STATE_SYSEX_0:
476 f_midi_transmit_packet(req,
477 p0 | 0x05, 0xf7, 0, 0);
478 break;
479 case STATE_SYSEX_1:
480 f_midi_transmit_packet(req,
481 p0 | 0x06, port->data[0], 0xf7, 0);
482 break;
483 case STATE_SYSEX_2:
484 f_midi_transmit_packet(req,
485 p0 | 0x07, port->data[0],
486 port->data[1], 0xf7);
487 break;
488 }
489 port->state = STATE_UNKNOWN;
490 break;
491 }
492 } else if (b >= 0x80) {
493 port->data[0] = b;
494 if (b >= 0xc0 && b <= 0xdf)
495 port->state = STATE_1PARAM;
496 else
497 port->state = STATE_2PARAM_1;
498 } else { /* b < 0x80 */
499 switch (port->state) {
500 case STATE_1PARAM:
501 if (port->data[0] < 0xf0) {
502 p0 |= port->data[0] >> 4;
503 } else {
504 p0 |= 0x02;
505 port->state = STATE_UNKNOWN;
506 }
507 f_midi_transmit_packet(req, p0, port->data[0], b, 0);
508 break;
509 case STATE_2PARAM_1:
510 port->data[1] = b;
511 port->state = STATE_2PARAM_2;
512 break;
513 case STATE_2PARAM_2:
514 if (port->data[0] < 0xf0) {
515 p0 |= port->data[0] >> 4;
516 port->state = STATE_2PARAM_1;
517 } else {
518 p0 |= 0x03;
519 port->state = STATE_UNKNOWN;
520 }
521 f_midi_transmit_packet(req,
522 p0, port->data[0], port->data[1], b);
523 break;
524 case STATE_SYSEX_0:
525 port->data[0] = b;
526 port->state = STATE_SYSEX_1;
527 break;
528 case STATE_SYSEX_1:
529 port->data[1] = b;
530 port->state = STATE_SYSEX_2;
531 break;
532 case STATE_SYSEX_2:
533 f_midi_transmit_packet(req,
534 p0 | 0x04, port->data[0], port->data[1], b);
535 port->state = STATE_SYSEX_0;
536 break;
537 }
538 }
539}
540
541static void f_midi_transmit(struct f_midi *midi, struct usb_request *req)
542{
543 struct usb_ep *ep = midi->in_ep;
544 int i;
545
546 if (!ep)
547 return;
548
549 if (!req)
550 req = alloc_ep_req(ep, midi->buflen);
551
552 if (!req) {
553 ERROR(midi, "gmidi_transmit: alloc_ep_request failed\n");
554 return;
555 }
556 req->length = 0;
557 req->complete = f_midi_complete;
558
559 for (i = 0; i < MAX_PORTS; i++) {
560 struct gmidi_in_port *port = midi->in_port[i];
561 struct snd_rawmidi_substream *substream = midi->in_substream[i];
562
563 if (!port || !port->active || !substream)
564 continue;
565
566 while (req->length + 3 < midi->buflen) {
567 uint8_t b;
568 if (snd_rawmidi_transmit(substream, &b, 1) != 1) {
569 port->active = 0;
570 break;
571 }
572 f_midi_transmit_byte(req, port, b);
573 }
574 }
575
576 if (req->length > 0)
577 usb_ep_queue(ep, req, GFP_ATOMIC);
578 else
579 free_ep_req(ep, req);
580}
581
582static void f_midi_in_tasklet(unsigned long data)
583{
584 struct f_midi *midi = (struct f_midi *) data;
585 f_midi_transmit(midi, NULL);
586}
587
588static int f_midi_in_open(struct snd_rawmidi_substream *substream)
589{
590 struct f_midi *midi = substream->rmidi->private_data;
591
592 if (!midi->in_port[substream->number])
593 return -EINVAL;
594
595 VDBG(midi, "%s()\n", __func__);
596 midi->in_substream[substream->number] = substream;
597 midi->in_port[substream->number]->state = STATE_UNKNOWN;
598 return 0;
599}
600
601static int f_midi_in_close(struct snd_rawmidi_substream *substream)
602{
603 struct f_midi *midi = substream->rmidi->private_data;
604
605 VDBG(midi, "%s()\n", __func__);
606 return 0;
607}
608
609static void f_midi_in_trigger(struct snd_rawmidi_substream *substream, int up)
610{
611 struct f_midi *midi = substream->rmidi->private_data;
612
613 if (!midi->in_port[substream->number])
614 return;
615
616 VDBG(midi, "%s() %d\n", __func__, up);
617 midi->in_port[substream->number]->active = up;
618 if (up)
619 tasklet_hi_schedule(&midi->tasklet);
620}
621
622static int f_midi_out_open(struct snd_rawmidi_substream *substream)
623{
624 struct f_midi *midi = substream->rmidi->private_data;
625
626 if (substream->number >= MAX_PORTS)
627 return -EINVAL;
628
629 VDBG(midi, "%s()\n", __func__);
630 midi->out_substream[substream->number] = substream;
631 return 0;
632}
633
634static int f_midi_out_close(struct snd_rawmidi_substream *substream)
635{
636 struct f_midi *midi = substream->rmidi->private_data;
637
638 VDBG(midi, "%s()\n", __func__);
639 return 0;
640}
641
642static void f_midi_out_trigger(struct snd_rawmidi_substream *substream, int up)
643{
644 struct f_midi *midi = substream->rmidi->private_data;
645
646 VDBG(midi, "%s()\n", __func__);
647
648 if (up)
649 set_bit(substream->number, &midi->out_triggered);
650 else
651 clear_bit(substream->number, &midi->out_triggered);
652}
653
654static struct snd_rawmidi_ops gmidi_in_ops = {
655 .open = f_midi_in_open,
656 .close = f_midi_in_close,
657 .trigger = f_midi_in_trigger,
658};
659
660static struct snd_rawmidi_ops gmidi_out_ops = {
661 .open = f_midi_out_open,
662 .close = f_midi_out_close,
663 .trigger = f_midi_out_trigger
664};
665
666/* register as a sound "card" */
667static int f_midi_register_card(struct f_midi *midi)
668{
669 struct snd_card *card;
670 struct snd_rawmidi *rmidi;
671 int err;
672 static struct snd_device_ops ops = {
673 .dev_free = f_midi_snd_free,
674 };
675
676 err = snd_card_create(midi->index, midi->id, THIS_MODULE, 0, &card);
677 if (err < 0) {
678 ERROR(midi, "snd_card_create() failed\n");
679 goto fail;
680 }
681 midi->card = card;
682
683 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, midi, &ops);
684 if (err < 0) {
685 ERROR(midi, "snd_device_new() failed: error %d\n", err);
686 goto fail;
687 }
688
689 strcpy(card->driver, f_midi_longname);
690 strcpy(card->longname, f_midi_longname);
691 strcpy(card->shortname, f_midi_shortname);
692
693 /* Set up rawmidi */
694 snd_component_add(card, "MIDI");
695 err = snd_rawmidi_new(card, card->longname, 0,
696 midi->out_ports, midi->in_ports, &rmidi);
697 if (err < 0) {
698 ERROR(midi, "snd_rawmidi_new() failed: error %d\n", err);
699 goto fail;
700 }
701 midi->rmidi = rmidi;
702 strcpy(rmidi->name, card->shortname);
703 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
704 SNDRV_RAWMIDI_INFO_INPUT |
705 SNDRV_RAWMIDI_INFO_DUPLEX;
706 rmidi->private_data = midi;
707
708 /*
709 * Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT.
710 * It's an upside-down world being a gadget.
711 */
712 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops);
713 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops);
714
715 snd_card_set_dev(card, &midi->gadget->dev);
716
717 /* register it - we're ready to go */
718 err = snd_card_register(card);
719 if (err < 0) {
720 ERROR(midi, "snd_card_register() failed\n");
721 goto fail;
722 }
723
724 VDBG(midi, "%s() finished ok\n", __func__);
725 return 0;
726
727fail:
728 if (midi->card) {
729 snd_card_free(midi->card);
730 midi->card = NULL;
731 }
732 return err;
733}
734
735/* MIDI function driver setup/binding */
736
737static int __init
738f_midi_bind(struct usb_configuration *c, struct usb_function *f)
739{
740 struct usb_descriptor_header **midi_function;
741 struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS];
742 struct usb_midi_in_jack_descriptor jack_in_emb_desc[MAX_PORTS];
743 struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc[MAX_PORTS];
744 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS];
745 struct usb_composite_dev *cdev = c->cdev;
746 struct f_midi *midi = func_to_midi(f);
747 int status, n, jack = 1, i = 0;
748
749 /* maybe allocate device-global string ID */
750 if (midi_string_defs[0].id == 0) {
751 status = usb_string_id(c->cdev);
752 if (status < 0)
753 goto fail;
754 midi_string_defs[0].id = status;
755 }
756
757 /* We have two interfaces, AudioControl and MIDIStreaming */
758 status = usb_interface_id(c, f);
759 if (status < 0)
760 goto fail;
761 ac_interface_desc.bInterfaceNumber = status;
762
763 status = usb_interface_id(c, f);
764 if (status < 0)
765 goto fail;
766 ms_interface_desc.bInterfaceNumber = status;
767 ac_header_desc.baInterfaceNr[0] = status;
768
769 status = -ENODEV;
770
771 /* allocate instance-specific endpoints */
772 midi->in_ep = usb_ep_autoconfig(cdev->gadget, &bulk_in_desc);
773 if (!midi->in_ep)
774 goto fail;
775 midi->in_ep->driver_data = cdev; /* claim */
776
777 midi->out_ep = usb_ep_autoconfig(cdev->gadget, &bulk_out_desc);
778 if (!midi->out_ep)
779 goto fail;
780 midi->out_ep->driver_data = cdev; /* claim */
781
782 /* allocate temporary function list */
783 midi_function = kcalloc((MAX_PORTS * 4) + 9, sizeof(midi_function),
784 GFP_KERNEL);
785 if (!midi_function) {
786 status = -ENOMEM;
787 goto fail;
788 }
789
790 /*
791 * construct the function's descriptor set. As the number of
792 * input and output MIDI ports is configurable, we have to do
793 * it that way.
794 */
795
796 /* add the headers - these are always the same */
797 midi_function[i++] = (struct usb_descriptor_header *) &ac_interface_desc;
798 midi_function[i++] = (struct usb_descriptor_header *) &ac_header_desc;
799 midi_function[i++] = (struct usb_descriptor_header *) &ms_interface_desc;
800
801 /* calculate the header's wTotalLength */
802 n = USB_DT_MS_HEADER_SIZE
803 + (midi->in_ports + midi->out_ports) *
804 (USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
805 ms_header_desc.wTotalLength = cpu_to_le16(n);
806
807 midi_function[i++] = (struct usb_descriptor_header *) &ms_header_desc;
808
809 /* configure the external IN jacks, each linked to an embedded OUT jack */
810 for (n = 0; n < midi->in_ports; n++) {
811 struct usb_midi_in_jack_descriptor *in_ext = &jack_in_ext_desc[n];
812 struct usb_midi_out_jack_descriptor_1 *out_emb = &jack_out_emb_desc[n];
813
814 in_ext->bLength = USB_DT_MIDI_IN_SIZE;
815 in_ext->bDescriptorType = USB_DT_CS_INTERFACE;
816 in_ext->bDescriptorSubtype = USB_MS_MIDI_IN_JACK;
817 in_ext->bJackType = USB_MS_EXTERNAL;
818 in_ext->bJackID = jack++;
819 in_ext->iJack = 0;
820 midi_function[i++] = (struct usb_descriptor_header *) in_ext;
821
822 out_emb->bLength = USB_DT_MIDI_OUT_SIZE(1);
823 out_emb->bDescriptorType = USB_DT_CS_INTERFACE;
824 out_emb->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK;
825 out_emb->bJackType = USB_MS_EMBEDDED;
826 out_emb->bJackID = jack++;
827 out_emb->bNrInputPins = 1;
828 out_emb->pins[0].baSourcePin = 1;
829 out_emb->pins[0].baSourceID = in_ext->bJackID;
830 out_emb->iJack = 0;
831 midi_function[i++] = (struct usb_descriptor_header *) out_emb;
832
833 /* link it to the endpoint */
834 ms_in_desc.baAssocJackID[n] = out_emb->bJackID;
835 }
836
837 /* configure the external OUT jacks, each linked to an embedded IN jack */
838 for (n = 0; n < midi->out_ports; n++) {
839 struct usb_midi_in_jack_descriptor *in_emb = &jack_in_emb_desc[n];
840 struct usb_midi_out_jack_descriptor_1 *out_ext = &jack_out_ext_desc[n];
841
842 in_emb->bLength = USB_DT_MIDI_IN_SIZE;
843 in_emb->bDescriptorType = USB_DT_CS_INTERFACE;
844 in_emb->bDescriptorSubtype = USB_MS_MIDI_IN_JACK;
845 in_emb->bJackType = USB_MS_EMBEDDED;
846 in_emb->bJackID = jack++;
847 in_emb->iJack = 0;
848 midi_function[i++] = (struct usb_descriptor_header *) in_emb;
849
850 out_ext->bLength = USB_DT_MIDI_OUT_SIZE(1);
851 out_ext->bDescriptorType = USB_DT_CS_INTERFACE;
852 out_ext->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK;
853 out_ext->bJackType = USB_MS_EXTERNAL;
854 out_ext->bJackID = jack++;
855 out_ext->bNrInputPins = 1;
856 out_ext->iJack = 0;
857 out_ext->pins[0].baSourceID = in_emb->bJackID;
858 out_ext->pins[0].baSourcePin = 1;
859 midi_function[i++] = (struct usb_descriptor_header *) out_ext;
860
861 /* link it to the endpoint */
862 ms_out_desc.baAssocJackID[n] = in_emb->bJackID;
863 }
864
865 /* configure the endpoint descriptors ... */
866 ms_out_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->in_ports);
867 ms_out_desc.bNumEmbMIDIJack = midi->in_ports;
868
869 ms_in_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->out_ports);
870 ms_in_desc.bNumEmbMIDIJack = midi->out_ports;
871
872 /* ... and add them to the list */
873 midi_function[i++] = (struct usb_descriptor_header *) &bulk_out_desc;
874 midi_function[i++] = (struct usb_descriptor_header *) &ms_out_desc;
875 midi_function[i++] = (struct usb_descriptor_header *) &bulk_in_desc;
876 midi_function[i++] = (struct usb_descriptor_header *) &ms_in_desc;
877 midi_function[i++] = NULL;
878
879 /*
880 * support all relevant hardware speeds... we expect that when
881 * hardware is dual speed, all bulk-capable endpoints work at
882 * both speeds
883 */
884 /* copy descriptors, and track endpoint copies */
885 if (gadget_is_dualspeed(c->cdev->gadget)) {
886 c->highspeed = true;
887 bulk_in_desc.wMaxPacketSize = cpu_to_le16(512);
888 bulk_out_desc.wMaxPacketSize = cpu_to_le16(512);
889 f->hs_descriptors = usb_copy_descriptors(midi_function);
890 } else {
891 f->descriptors = usb_copy_descriptors(midi_function);
892 }
893
894 kfree(midi_function);
895
896 return 0;
897
898fail:
899 /* we might as well release our claims on endpoints */
900 if (midi->out_ep)
901 midi->out_ep->driver_data = NULL;
902 if (midi->in_ep)
903 midi->in_ep->driver_data = NULL;
904
905 ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
906
907 return status;
908}
909
910/**
911 * f_midi_bind_config - add USB MIDI function to a configuration
912 * @c: the configuration to supcard the USB audio function
913 * @index: the soundcard index to use for the ALSA device creation
914 * @id: the soundcard id to use for the ALSA device creation
915 * @buflen: the buffer length to use
916 * @qlen the number of read requests to pre-allocate
917 * Context: single threaded during gadget setup
918 *
919 * Returns zero on success, else negative errno.
920 */
921int __init f_midi_bind_config(struct usb_configuration *c,
922 int index, char *id,
923 unsigned int in_ports,
924 unsigned int out_ports,
925 unsigned int buflen,
926 unsigned int qlen)
927{
928 struct f_midi *midi;
929 int status, i;
930
931 /* sanity check */
932 if (in_ports > MAX_PORTS || out_ports > MAX_PORTS)
933 return -EINVAL;
934
935 /* allocate and initialize one new instance */
936 midi = kzalloc(sizeof *midi, GFP_KERNEL);
937 if (!midi) {
938 status = -ENOMEM;
939 goto fail;
940 }
941
942 for (i = 0; i < in_ports; i++) {
943 struct gmidi_in_port *port = kzalloc(sizeof(*port), GFP_KERNEL);
944 if (!port) {
945 status = -ENOMEM;
946 goto setup_fail;
947 }
948
949 port->midi = midi;
950 port->active = 0;
951 port->cable = i;
952 midi->in_port[i] = port;
953 }
954
955 midi->gadget = c->cdev->gadget;
956 tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi);
957
958 /* set up ALSA midi devices */
959 midi->in_ports = in_ports;
960 midi->out_ports = out_ports;
961 status = f_midi_register_card(midi);
962 if (status < 0)
963 goto setup_fail;
964
965 midi->func.name = "gmidi function";
966 midi->func.strings = midi_strings;
967 midi->func.bind = f_midi_bind;
968 midi->func.unbind = f_midi_unbind;
969 midi->func.set_alt = f_midi_set_alt;
970 midi->func.disable = f_midi_disable;
971
972 midi->id = kstrdup(id, GFP_KERNEL);
973 midi->index = index;
974 midi->buflen = buflen;
975 midi->qlen = qlen;
976
977 status = usb_add_function(c, &midi->func);
978 if (status)
979 goto setup_fail;
980
981 return 0;
982
983setup_fail:
984 for (--i; i >= 0; i--)
985 kfree(midi->in_port[i]);
986 kfree(midi);
987fail:
988 return status;
989}
990
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-28 12:05:51 -0500