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