projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
usb: gadget: uvc: fix error path in uvc_function_bind()
[deliverable/linux.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>
d5daf49b
DM		 24#include <linux/device.h>
25
26#include <sound/core.h>
27#include <sound/initval.h>
28#include <sound/rawmidi.h>
29
30#include <linux/usb/ch9.h>
31#include <linux/usb/gadget.h>
32#include <linux/usb/audio.h>
33#include <linux/usb/midi.h>
34
35MODULE_AUTHOR("Ben Williamson");
36MODULE_LICENSE("GPL v2");
37
38static const char f_midi_shortname[] = "f_midi";
39static const char f_midi_longname[] = "MIDI Gadget";
40
c8933c3f
DM		 41/*
42 * We can only handle 16 cables on one single endpoint, as cable numbers are
43 * stored in 4-bit fields. And as the interface currently only holds one
44 * single endpoint, this is the maximum number of ports we can allow.
45 */
46#define MAX_PORTS 16
47
d5daf49b
DM		 48/*
49 * This is a gadget, and the IN/OUT naming is from the host's perspective.
50 * USB -> OUT endpoint -> rawmidi
51 * USB <- IN endpoint <- rawmidi
52 */
53struct gmidi_in_port {
54 struct f_midi *midi;
55 int active;
c8933c3f 56 uint8_t cable;
d5daf49b
DM		 57 uint8_t state;
58#define STATE_UNKNOWN 0
59#define STATE_1PARAM 1
60#define STATE_2PARAM_1 2
61#define STATE_2PARAM_2 3
62#define STATE_SYSEX_0 4
63#define STATE_SYSEX_1 5
64#define STATE_SYSEX_2 6
65 uint8_t data[2];
66};
67
68struct f_midi {
69 struct usb_function func;
70 struct usb_gadget *gadget;
71 struct usb_ep *in_ep, *out_ep;
72 struct snd_card *card;
73 struct snd_rawmidi *rmidi;
d5daf49b 74
c8933c3f
DM		 75 struct snd_rawmidi_substream *in_substream[MAX_PORTS];
76 struct snd_rawmidi_substream *out_substream[MAX_PORTS];
77 struct gmidi_in_port *in_port[MAX_PORTS];
78
d5daf49b
DM		 79 unsigned long out_triggered;
80 struct tasklet_struct tasklet;
c8933c3f
DM		 81 unsigned int in_ports;
82 unsigned int out_ports;
d5daf49b
DM		 83 int index;
84 char *id;
85 unsigned int buflen, qlen;
86};
87
88static inline struct f_midi *func_to_midi(struct usb_function *f)
89{
90 return container_of(f, struct f_midi, func);
91}
92
93static void f_midi_transmit(struct f_midi *midi, struct usb_request *req);
94
95DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
96DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
c8933c3f 97DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
d5daf49b
DM		 98
99/* B.3.1 Standard AC Interface Descriptor */
100static struct usb_interface_descriptor ac_interface_desc __initdata = {
101 .bLength = USB_DT_INTERFACE_SIZE,
102 .bDescriptorType = USB_DT_INTERFACE,
103 /* .bInterfaceNumber = DYNAMIC */
104 /* .bNumEndpoints = DYNAMIC */
105 .bInterfaceClass = USB_CLASS_AUDIO,
106 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
107 /* .iInterface = DYNAMIC */
108};
109
110/* B.3.2 Class-Specific AC Interface Descriptor */
111static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = {
112 .bLength = UAC_DT_AC_HEADER_SIZE(1),
113 .bDescriptorType = USB_DT_CS_INTERFACE,
114 .bDescriptorSubtype = USB_MS_HEADER,
115 .bcdADC = cpu_to_le16(0x0100),
116 .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
117 .bInCollection = 1,
118 /* .baInterfaceNr = DYNAMIC */
119};
120
121/* B.4.1 Standard MS Interface Descriptor */
122static struct usb_interface_descriptor ms_interface_desc __initdata = {
123 .bLength = USB_DT_INTERFACE_SIZE,
124 .bDescriptorType = USB_DT_INTERFACE,
125 /* .bInterfaceNumber = DYNAMIC */
126 .bNumEndpoints = 2,
127 .bInterfaceClass = USB_CLASS_AUDIO,
128 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
129 /* .iInterface = DYNAMIC */
130};
131
132/* B.4.2 Class-Specific MS Interface Descriptor */
133static struct usb_ms_header_descriptor ms_header_desc __initdata = {
134 .bLength = USB_DT_MS_HEADER_SIZE,
135 .bDescriptorType = USB_DT_CS_INTERFACE,
136 .bDescriptorSubtype = USB_MS_HEADER,
137 .bcdMSC = cpu_to_le16(0x0100),
c8933c3f 138 /* .wTotalLength = DYNAMIC */
d5daf49b
DM		 139};
140
d5daf49b
DM		 141/* B.5.1 Standard Bulk OUT Endpoint Descriptor */
142static struct usb_endpoint_descriptor bulk_out_desc = {
143 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
144 .bDescriptorType = USB_DT_ENDPOINT,
145 .bEndpointAddress = USB_DIR_OUT,
146 .bmAttributes = USB_ENDPOINT_XFER_BULK,
147};
148
149/* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */
c8933c3f
DM		 150static struct usb_ms_endpoint_descriptor_16 ms_out_desc = {
151 /* .bLength = DYNAMIC */
d5daf49b
DM		 152 .bDescriptorType = USB_DT_CS_ENDPOINT,
153 .bDescriptorSubtype = USB_MS_GENERAL,
c8933c3f
DM		 154 /* .bNumEmbMIDIJack = DYNAMIC */
155 /* .baAssocJackID = DYNAMIC */
d5daf49b
DM		 156};
157
158/* B.6.1 Standard Bulk IN Endpoint Descriptor */
159static struct usb_endpoint_descriptor bulk_in_desc = {
160 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
161 .bDescriptorType = USB_DT_ENDPOINT,
162 .bEndpointAddress = USB_DIR_IN,
163 .bmAttributes = USB_ENDPOINT_XFER_BULK,
164};
165
166/* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */
c8933c3f
DM		 167static struct usb_ms_endpoint_descriptor_16 ms_in_desc = {
168 /* .bLength = DYNAMIC */
d5daf49b
DM		 169 .bDescriptorType = USB_DT_CS_ENDPOINT,
170 .bDescriptorSubtype = USB_MS_GENERAL,
c8933c3f
DM		 171 /* .bNumEmbMIDIJack = DYNAMIC */
172 /* .baAssocJackID = DYNAMIC */
d5daf49b
DM		 173};
174
175/* string IDs are assigned dynamically */
176
177#define STRING_FUNC_IDX 0
178
179static struct usb_string midi_string_defs[] = {
180 [STRING_FUNC_IDX].s = "MIDI function",
181 { } /* end of list */
182};
183
184static struct usb_gadget_strings midi_stringtab = {
185 .language = 0x0409, /* en-us */
186 .strings = midi_string_defs,
187};
188
189static struct usb_gadget_strings *midi_strings[] = {
190 &midi_stringtab,
191 NULL,
192};
193
194static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
195{
196 struct usb_request *req;
197
198 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
199 if (req) {
200 req->length = length;
201 req->buf = kmalloc(length, GFP_ATOMIC);
202 if (!req->buf) {
203 usb_ep_free_request(ep, req);
204 req = NULL;
205 }
206 }
207 return req;
208}
209
210static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
211{
212 kfree(req->buf);
213 usb_ep_free_request(ep, req);
214}
215
216static const uint8_t f_midi_cin_length[] = {
217 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
218};
219
220/*
221 * Receives a chunk of MIDI data.
222 */
223static void f_midi_read_data(struct usb_ep *ep, int cable,
224 uint8_t *data, int length)
225{
226 struct f_midi *midi = ep->driver_data;
c8933c3f 227 struct snd_rawmidi_substream *substream = midi->out_substream[cable];
d5daf49b 228
c8933c3f 229 if (!substream)
d5daf49b
DM		 230 /* Nobody is listening - throw it on the floor. */
231 return;
232
c8933c3f 233 if (!test_bit(cable, &midi->out_triggered))
d5daf49b
DM		 234 return;
235
c8933c3f 236 snd_rawmidi_receive(substream, data, length);
d5daf49b
DM		 237}
238
239static void f_midi_handle_out_data(struct usb_ep *ep, struct usb_request *req)
240{
241 unsigned int i;
242 u8 *buf = req->buf;
243
244 for (i = 0; i + 3 < req->actual; i += 4)
245 if (buf[i] != 0) {
246 int cable = buf[i] >> 4;
247 int length = f_midi_cin_length[buf[i] & 0x0f];
248 f_midi_read_data(ep, cable, &buf[i + 1], length);
249 }
250}
251
252static void
253f_midi_complete(struct usb_ep *ep, struct usb_request *req)
254{
255 struct f_midi *midi = ep->driver_data;
256 struct usb_composite_dev *cdev = midi->func.config->cdev;
257 int status = req->status;
258
259 switch (status) {
260 case 0: /* normal completion */
261 if (ep == midi->out_ep) {
262 /* We received stuff. req is queued again, below */
263 f_midi_handle_out_data(ep, req);
264 } else if (ep == midi->in_ep) {
265 /* Our transmit completed. See if there's more to go.
266 * f_midi_transmit eats req, don't queue it again. */
267 f_midi_transmit(midi, req);
268 return;
269 }
270 break;
271
272 /* this endpoint is normally active while we're configured */
273 case -ECONNABORTED: /* hardware forced ep reset */
274 case -ECONNRESET: /* request dequeued */
275 case -ESHUTDOWN: /* disconnect from host */
276 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
277 req->actual, req->length);
278 if (ep == midi->out_ep)
279 f_midi_handle_out_data(ep, req);
280
281 free_ep_req(ep, req);
282 return;
283
284 case -EOVERFLOW: /* buffer overrun on read means that
285 * we didn't provide a big enough buffer.
286 */
287 default:
288 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
289 status, req->actual, req->length);
290 break;
291 case -EREMOTEIO: /* short read */
292 break;
293 }
294
295 status = usb_ep_queue(ep, req, GFP_ATOMIC);
296 if (status) {
297 ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n",
298 ep->name, req->length, status);
299 usb_ep_set_halt(ep);
300 /* FIXME recover later ... somehow */
301 }
302}
303
304static int f_midi_start_ep(struct f_midi *midi,
305 struct usb_function *f,
306 struct usb_ep *ep)
307{
308 int err;
309 struct usb_composite_dev *cdev = f->config->cdev;
310
311 if (ep->driver_data)
312 usb_ep_disable(ep);
313
314 err = config_ep_by_speed(midi->gadget, f, ep);
315 if (err) {
316 ERROR(cdev, "can't configure %s: %d\n", ep->name, err);
317 return err;
318 }
319
320 err = usb_ep_enable(ep);
321 if (err) {
322 ERROR(cdev, "can't start %s: %d\n", ep->name, err);
323 return err;
324 }
325
326 ep->driver_data = midi;
327
328 return 0;
329}
330
331static int f_midi_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
332{
333 struct f_midi *midi = func_to_midi(f);
334 struct usb_composite_dev *cdev = f->config->cdev;
335 unsigned i;
336 int err;
337
338 err = f_midi_start_ep(midi, f, midi->in_ep);
339 if (err)
340 return err;
341
342 err = f_midi_start_ep(midi, f, midi->out_ep);
343 if (err)
344 return err;
345
346 if (midi->out_ep->driver_data)
347 usb_ep_disable(midi->out_ep);
348
349 err = config_ep_by_speed(midi->gadget, f, midi->out_ep);
350 if (err) {
351 ERROR(cdev, "can't configure %s: %d\n",
352 midi->out_ep->name, err);
353 return err;
354 }
355
356 err = usb_ep_enable(midi->out_ep);
357 if (err) {
358 ERROR(cdev, "can't start %s: %d\n",
359 midi->out_ep->name, err);
360 return err;
361 }
362
363 midi->out_ep->driver_data = midi;
364
365 /* allocate a bunch of read buffers and queue them all at once. */
366 for (i = 0; i < midi->qlen && err == 0; i++) {
367 struct usb_request *req =
368 alloc_ep_req(midi->out_ep, midi->buflen);
369 if (req == NULL)
370 return -ENOMEM;
371
372 req->complete = f_midi_complete;
373 err = usb_ep_queue(midi->out_ep, req, GFP_ATOMIC);
374 if (err) {
375 ERROR(midi, "%s queue req: %d\n",
376 midi->out_ep->name, err);
377 }
378 }
379
380 return 0;
381}
382
383static void f_midi_disable(struct usb_function *f)
384{
385 struct f_midi *midi = func_to_midi(f);
386 struct usb_composite_dev *cdev = f->config->cdev;
387
388 DBG(cdev, "disable\n");
389
390 /*
391 * just disable endpoints, forcing completion of pending i/o.
392 * all our completion handlers free their requests in this case.
393 */
394 usb_ep_disable(midi->in_ep);
395 usb_ep_disable(midi->out_ep);
396}
397
398static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
399{
400 struct usb_composite_dev *cdev = f->config->cdev;
401 struct f_midi *midi = func_to_midi(f);
402 struct snd_card *card;
403
404 DBG(cdev, "unbind\n");
405
406 /* just to be sure */
407 f_midi_disable(f);
408
409 card = midi->card;
410 midi->card = NULL;
411 if (card)
412 snd_card_free(card);
413
414 kfree(midi->id);
415 midi->id = NULL;
416
417 usb_free_descriptors(f->descriptors);
d185039f 418 usb_free_descriptors(f->hs_descriptors);
d5daf49b
DM		 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{
c8933c3f 446 uint8_t p0 = port->cable << 4;
d5daf49b
DM		 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;
c8933c3f 544 int i;
d5daf49b
DM		 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
c8933c3f
DM		 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
d5daf49b
DM		 566 while (req->length + 3 < midi->buflen) {
567 uint8_t b;
c8933c3f 568 if (snd_rawmidi_transmit(substream, &b, 1) != 1) {
d5daf49b
DM		 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
c8933c3f
DM		 592 if (!midi->in_port[substream->number])
593 return -EINVAL;
594
d5daf49b 595 VDBG(midi, "%s()\n", __func__);
c8933c3f
DM		 596 midi->in_substream[substream->number] = substream;
597 midi->in_port[substream->number]->state = STATE_UNKNOWN;
d5daf49b
DM		 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
c8933c3f
DM		 613 if (!midi->in_port[substream->number])
614 return;
615
d5daf49b 616 VDBG(midi, "%s() %d\n", __func__, up);
c8933c3f 617 midi->in_port[substream->number]->active = up;
d5daf49b
DM		 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
08895512 626 if (substream->number >= MAX_PORTS)
c8933c3f
DM		 627 return -EINVAL;
628
d5daf49b 629 VDBG(midi, "%s()\n", __func__);
c8933c3f 630 midi->out_substream[substream->number] = substream;
d5daf49b
DM		 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;
d5daf49b
DM		 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 */
d5daf49b
DM		 694 snd_component_add(card, "MIDI");
695 err = snd_rawmidi_new(card, card->longname, 0,
c8933c3f 696 midi->out_ports, midi->in_ports, &rmidi);
d5daf49b
DM		 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{
74203de0 740 struct usb_descriptor_header **midi_function;
c8933c3f 741 struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS];
74203de0 742 struct usb_midi_in_jack_descriptor jack_in_emb_desc[MAX_PORTS];
c8933c3f 743 struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc[MAX_PORTS];
74203de0 744 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS];
d5daf49b
DM		 745 struct usb_composite_dev *cdev = c->cdev;
746 struct f_midi *midi = func_to_midi(f);
c8933c3f 747 int status, n, jack = 1, i = 0;
d5daf49b
DM		 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
74203de0 782 /* allocate temporary function list */
2a5be878 783 midi_function = kcalloc((MAX_PORTS * 4) + 9, sizeof(*midi_function),
74203de0
DM		 784 GFP_KERNEL);
785 if (!midi_function) {
786 status = -ENOMEM;
787 goto fail;
788 }
789
c8933c3f
DM		 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
74203de0
DM		 803 + (midi->in_ports + midi->out_ports) *
804 (USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
c8933c3f
DM		 805 ms_header_desc.wTotalLength = cpu_to_le16(n);
806
807 midi_function[i++] = (struct usb_descriptor_header *) &ms_header_desc;
808
74203de0 809 /* configure the external IN jacks, each linked to an embedded OUT jack */
c8933c3f 810 for (n = 0; n < midi->in_ports; n++) {
74203de0
DM		 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;
c8933c3f
DM		 835 }
836
74203de0 837 /* configure the external OUT jacks, each linked to an embedded IN jack */
c8933c3f 838 for (n = 0; n < midi->out_ports; n++) {
74203de0
DM		 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;
c8933c3f
DM		 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;
c8933c3f
DM		 868
869 ms_in_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->out_ports);
870 ms_in_desc.bNumEmbMIDIJack = midi->out_ports;
c8933c3f
DM		 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
d5daf49b
DM		 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 */
7f2a9268
SAS		 885 f->descriptors = usb_copy_descriptors(midi_function);
886 if (!f->descriptors)
887 goto fail_f_midi;
d5daf49b 888 if (gadget_is_dualspeed(c->cdev->gadget)) {
d5daf49b
DM		 889 bulk_in_desc.wMaxPacketSize = cpu_to_le16(512);
890 bulk_out_desc.wMaxPacketSize = cpu_to_le16(512);
891 f->hs_descriptors = usb_copy_descriptors(midi_function);
7f2a9268
SAS		 892 if (!f->hs_descriptors)
893 goto fail_f_midi;
d5daf49b
DM		 894 }
895
74203de0
DM		 896 kfree(midi_function);
897
d5daf49b
DM		 898 return 0;
899
7f2a9268
SAS		 900fail_f_midi:
901 kfree(midi_function);
902 usb_free_descriptors(f->hs_descriptors);
d5daf49b
DM		 903fail:
904 /* we might as well release our claims on endpoints */
905 if (midi->out_ep)
906 midi->out_ep->driver_data = NULL;
907 if (midi->in_ep)
908 midi->in_ep->driver_data = NULL;
909
910 ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
911
912 return status;
913}
914
915/**
916 * f_midi_bind_config - add USB MIDI function to a configuration
917 * @c: the configuration to supcard the USB audio function
918 * @index: the soundcard index to use for the ALSA device creation
919 * @id: the soundcard id to use for the ALSA device creation
920 * @buflen: the buffer length to use
921 * @qlen the number of read requests to pre-allocate
922 * Context: single threaded during gadget setup
923 *
924 * Returns zero on success, else negative errno.
925 */
926int __init f_midi_bind_config(struct usb_configuration *c,
927 int index, char *id,
c8933c3f
DM		 928 unsigned int in_ports,
929 unsigned int out_ports,
d5daf49b
DM		 930 unsigned int buflen,
931 unsigned int qlen)
932{
933 struct f_midi *midi;
c8933c3f
DM		 934 int status, i;
935
936 /* sanity check */
937 if (in_ports > MAX_PORTS || out_ports > MAX_PORTS)
938 return -EINVAL;
d5daf49b
DM		 939
940 /* allocate and initialize one new instance */
941 midi = kzalloc(sizeof *midi, GFP_KERNEL);
942 if (!midi) {
943 status = -ENOMEM;
944 goto fail;
945 }
946
c8933c3f
DM		 947 for (i = 0; i < in_ports; i++) {
948 struct gmidi_in_port *port = kzalloc(sizeof(*port), GFP_KERNEL);
949 if (!port) {
950 status = -ENOMEM;
0f8fd43c 951 goto setup_fail;
c8933c3f
DM		 952 }
953
954 port->midi = midi;
955 port->active = 0;
956 port->cable = i;
957 midi->in_port[i] = port;
958 }
959
d5daf49b
DM		 960 midi->gadget = c->cdev->gadget;
961 tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi);
962
963 /* set up ALSA midi devices */
c8933c3f
DM		 964 midi->in_ports = in_ports;
965 midi->out_ports = out_ports;
d5daf49b
DM		 966 status = f_midi_register_card(midi);
967 if (status < 0)
968 goto setup_fail;
969
970 midi->func.name = "gmidi function";
971 midi->func.strings = midi_strings;
972 midi->func.bind = f_midi_bind;
973 midi->func.unbind = f_midi_unbind;
974 midi->func.set_alt = f_midi_set_alt;
975 midi->func.disable = f_midi_disable;
976
977 midi->id = kstrdup(id, GFP_KERNEL);
978 midi->index = index;
979 midi->buflen = buflen;
980 midi->qlen = qlen;
981
982 status = usb_add_function(c, &midi->func);
983 if (status)
984 goto setup_fail;
985
986 return 0;
987
988setup_fail:
0f8fd43c
DC		 989 for (--i; i >= 0; i--)
990 kfree(midi->in_port[i]);
d5daf49b
DM		 991 kfree(midi);
992fail:
993 return status;
994}
995
Linux kernel - Deliverables
This page took 0.216762 seconds and 5 git commands to generate.