?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/PCI: use host bridge _CRS info on ASUS M2V-MX SE
[linux-btrfs-devel.git] / drivers / usb / gadget / gmidi.c
blob8b9220e128a7f8023bea11acb07aa2d67592db0e
1 /*
2 * gmidi.c -- USB MIDI Gadget 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 * This software is distributed under the terms of the GNU General Public
9 * License ("GPL") version 2, as published by the Free Software Foundation.
10 *
11 * This code is based in part on:
12 *
13 * Gadget Zero driver, Copyright (C) 2003-2004 David Brownell.
14 * USB Audio driver, Copyright (C) 2002 by Takashi Iwai.
15 * USB MIDI driver, Copyright (C) 2002-2005 Clemens Ladisch.
16 *
17 * Refer to the USB Device Class Definition for MIDI Devices:
18 * http://www.usb.org/developers/devclass_docs/midi10.pdf
19 */
20
21 /* #define VERBOSE_DEBUG */
22
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/utsname.h>
26 #include <linux/device.h>
27
28 #include <sound/core.h>
29 #include <sound/initval.h>
30 #include <sound/rawmidi.h>
31
32 #include <linux/usb/ch9.h>
33 #include <linux/usb/gadget.h>
34 #include <linux/usb/audio.h>
35 #include <linux/usb/midi.h>
36
37 #include "gadget_chips.h"
38
39
40 /*
41 * Kbuild is not very cooperative with respect to linking separately
42 * compiled library objects into one module. So for now we won't use
43 * separate compilation ... ensuring init/exit sections work to shrink
44 * the runtime footprint, and giving us at least some parts of what
45 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
46 */
47 #include "usbstring.c"
48 #include "config.c"
49 #include "epautoconf.c"
50
51 /*-------------------------------------------------------------------------*/
52
53
54 MODULE_AUTHOR("Ben Williamson");
55 MODULE_LICENSE("GPL v2");
56
57 #define DRIVER_VERSION "25 Jul 2006"
58
59 static const char shortname[] = "g_midi";
60 static const char longname[] = "MIDI Gadget";
61
62 static int index = SNDRV_DEFAULT_IDX1;
63 static char *id = SNDRV_DEFAULT_STR1;
64
65 module_param(index, int, 0444);
66 MODULE_PARM_DESC(index, "Index value for the USB MIDI Gadget adapter.");
67 module_param(id, charp, 0444);
68 MODULE_PARM_DESC(id, "ID string for the USB MIDI Gadget adapter.");
69
70 /* Some systems will want different product identifiers published in the
71 * device descriptor, either numbers or strings or both. These string
72 * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
73 */
74
75 static ushort idVendor;
76 module_param(idVendor, ushort, S_IRUGO);
77 MODULE_PARM_DESC(idVendor, "USB Vendor ID");
78
79 static ushort idProduct;
80 module_param(idProduct, ushort, S_IRUGO);
81 MODULE_PARM_DESC(idProduct, "USB Product ID");
82
83 static ushort bcdDevice;
84 module_param(bcdDevice, ushort, S_IRUGO);
85 MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
86
87 static char *iManufacturer;
88 module_param(iManufacturer, charp, S_IRUGO);
89 MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
90
91 static char *iProduct;
92 module_param(iProduct, charp, S_IRUGO);
93 MODULE_PARM_DESC(iProduct, "USB Product string");
94
95 static char *iSerialNumber;
96 module_param(iSerialNumber, charp, S_IRUGO);
97 MODULE_PARM_DESC(iSerialNumber, "SerialNumber");
98
99 /*
100 * this version autoconfigures as much as possible,
101 * which is reasonable for most "bulk-only" drivers.
102 */
103 static const char *EP_IN_NAME;
104 static const char *EP_OUT_NAME;
105
106
107 /* big enough to hold our biggest descriptor */
108 #define USB_BUFSIZ 256
109
110
111 /* This is a gadget, and the IN/OUT naming is from the host's perspective.
112 USB -> OUT endpoint -> rawmidi
113 USB <- IN endpoint <- rawmidi */
114 struct gmidi_in_port {
115 struct gmidi_device* dev;
116 int active;
117 uint8_t cable; /* cable number << 4 */
118 uint8_t state;
119 #define STATE_UNKNOWN 0
120 #define STATE_1PARAM 1
121 #define STATE_2PARAM_1 2
122 #define STATE_2PARAM_2 3
123 #define STATE_SYSEX_0 4
124 #define STATE_SYSEX_1 5
125 #define STATE_SYSEX_2 6
126 uint8_t data[2];
127 };
128
129 struct gmidi_device {
130 spinlock_t lock;
131 struct usb_gadget *gadget;
132 struct usb_request *req; /* for control responses */
133 u8 config;
134 struct usb_ep *in_ep, *out_ep;
135 struct snd_card *card;
136 struct snd_rawmidi *rmidi;
137 struct snd_rawmidi_substream *in_substream;
138 struct snd_rawmidi_substream *out_substream;
139
140 /* For the moment we only support one port in
141 each direction, but in_port is kept as a
142 separate struct so we can have more later. */
143 struct gmidi_in_port in_port;
144 unsigned long out_triggered;
145 struct tasklet_struct tasklet;
146 };
147
148 static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req);
149
150
151 #define DBG(d, fmt, args...) \
152 dev_dbg(&(d)->gadget->dev , fmt , ## args)
153 #define VDBG(d, fmt, args...) \
154 dev_vdbg(&(d)->gadget->dev , fmt , ## args)
155 #define ERROR(d, fmt, args...) \
156 dev_err(&(d)->gadget->dev , fmt , ## args)
157 #define INFO(d, fmt, args...) \
158 dev_info(&(d)->gadget->dev , fmt , ## args)
159
160
161 static unsigned buflen = 256;
162 static unsigned qlen = 32;
163
164 module_param(buflen, uint, S_IRUGO);
165 module_param(qlen, uint, S_IRUGO);
166
167
168 /* Thanks to Grey Innovation for donating this product ID.
169 *
170 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
171 * Instead: allocate your own, using normal USB-IF procedures.
172 */
173 #define DRIVER_VENDOR_NUM 0x17b3 /* Grey Innovation */
174 #define DRIVER_PRODUCT_NUM 0x0004 /* Linux-USB "MIDI Gadget" */
175
176
177 /*
178 * DESCRIPTORS ... most are static, but strings and (full)
179 * configuration descriptors are built on demand.
180 */
181
182 #define STRING_MANUFACTURER 25
183 #define STRING_PRODUCT 42
184 #define STRING_SERIAL 101
185 #define STRING_MIDI_GADGET 250
186
187 /* We only have the one configuration, it's number 1. */
188 #define GMIDI_CONFIG 1
189
190 /* We have two interfaces- AudioControl and MIDIStreaming */
191 #define GMIDI_AC_INTERFACE 0
192 #define GMIDI_MS_INTERFACE 1
193 #define GMIDI_NUM_INTERFACES 2
194
195 DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
196 DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
197 DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(1);
198
199 /* B.1 Device Descriptor */
200 static struct usb_device_descriptor device_desc = {
201 .bLength = USB_DT_DEVICE_SIZE,
202 .bDescriptorType = USB_DT_DEVICE,
203 .bcdUSB = cpu_to_le16(0x0200),
204 .bDeviceClass = USB_CLASS_PER_INTERFACE,
205 .idVendor = cpu_to_le16(DRIVER_VENDOR_NUM),
206 .idProduct = cpu_to_le16(DRIVER_PRODUCT_NUM),
207 .iManufacturer = STRING_MANUFACTURER,
208 .iProduct = STRING_PRODUCT,
209 .bNumConfigurations = 1,
210 };
211
212 /* B.2 Configuration Descriptor */
213 static struct usb_config_descriptor config_desc = {
214 .bLength = USB_DT_CONFIG_SIZE,
215 .bDescriptorType = USB_DT_CONFIG,
216 /* compute wTotalLength on the fly */
217 .bNumInterfaces = GMIDI_NUM_INTERFACES,
218 .bConfigurationValue = GMIDI_CONFIG,
219 .iConfiguration = STRING_MIDI_GADGET,
220 /*
221 * FIXME: When embedding this driver in a device,
222 * these need to be set to reflect the actual
223 * power properties of the device. Is it selfpowered?
224 */
225 .bmAttributes = USB_CONFIG_ATT_ONE,
226 .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2,
227 };
228
229 /* B.3.1 Standard AC Interface Descriptor */
230 static const struct usb_interface_descriptor ac_interface_desc = {
231 .bLength = USB_DT_INTERFACE_SIZE,
232 .bDescriptorType = USB_DT_INTERFACE,
233 .bInterfaceNumber = GMIDI_AC_INTERFACE,
234 .bNumEndpoints = 0,
235 .bInterfaceClass = USB_CLASS_AUDIO,
236 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
237 .iInterface = STRING_MIDI_GADGET,
238 };
239
240 /* B.3.2 Class-Specific AC Interface Descriptor */
241 static const struct uac1_ac_header_descriptor_1 ac_header_desc = {
242 .bLength = UAC_DT_AC_HEADER_SIZE(1),
243 .bDescriptorType = USB_DT_CS_INTERFACE,
244 .bDescriptorSubtype = USB_MS_HEADER,
245 .bcdADC = cpu_to_le16(0x0100),
246 .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
247 .bInCollection = 1,
248 .baInterfaceNr = {
249 [0] = GMIDI_MS_INTERFACE,
250 }
251 };
252
253 /* B.4.1 Standard MS Interface Descriptor */
254 static const struct usb_interface_descriptor ms_interface_desc = {
255 .bLength = USB_DT_INTERFACE_SIZE,
256 .bDescriptorType = USB_DT_INTERFACE,
257 .bInterfaceNumber = GMIDI_MS_INTERFACE,
258 .bNumEndpoints = 2,
259 .bInterfaceClass = USB_CLASS_AUDIO,
260 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
261 .iInterface = STRING_MIDI_GADGET,
262 };
263
264 /* B.4.2 Class-Specific MS Interface Descriptor */
265 static const struct usb_ms_header_descriptor ms_header_desc = {
266 .bLength = USB_DT_MS_HEADER_SIZE,
267 .bDescriptorType = USB_DT_CS_INTERFACE,
268 .bDescriptorSubtype = USB_MS_HEADER,
269 .bcdMSC = cpu_to_le16(0x0100),
270 .wTotalLength = cpu_to_le16(USB_DT_MS_HEADER_SIZE
271 + 2*USB_DT_MIDI_IN_SIZE
272 + 2*USB_DT_MIDI_OUT_SIZE(1)),
273 };
274
275 #define JACK_IN_EMB 1
276 #define JACK_IN_EXT 2
277 #define JACK_OUT_EMB 3
278 #define JACK_OUT_EXT 4
279
280 /* B.4.3 MIDI IN Jack Descriptors */
281 static const struct usb_midi_in_jack_descriptor jack_in_emb_desc = {
282 .bLength = USB_DT_MIDI_IN_SIZE,
283 .bDescriptorType = USB_DT_CS_INTERFACE,
284 .bDescriptorSubtype = USB_MS_MIDI_IN_JACK,
285 .bJackType = USB_MS_EMBEDDED,
286 .bJackID = JACK_IN_EMB,
287 };
288
289 static const struct usb_midi_in_jack_descriptor jack_in_ext_desc = {
290 .bLength = USB_DT_MIDI_IN_SIZE,
291 .bDescriptorType = USB_DT_CS_INTERFACE,
292 .bDescriptorSubtype = USB_MS_MIDI_IN_JACK,
293 .bJackType = USB_MS_EXTERNAL,
294 .bJackID = JACK_IN_EXT,
295 };
296
297 /* B.4.4 MIDI OUT Jack Descriptors */
298 static const struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc = {
299 .bLength = USB_DT_MIDI_OUT_SIZE(1),
300 .bDescriptorType = USB_DT_CS_INTERFACE,
301 .bDescriptorSubtype = USB_MS_MIDI_OUT_JACK,
302 .bJackType = USB_MS_EMBEDDED,
303 .bJackID = JACK_OUT_EMB,
304 .bNrInputPins = 1,
305 .pins = {
306 [0] = {
307 .baSourceID = JACK_IN_EXT,
308 .baSourcePin = 1,
309 }
310 }
311 };
312
313 static const struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc = {
314 .bLength = USB_DT_MIDI_OUT_SIZE(1),
315 .bDescriptorType = USB_DT_CS_INTERFACE,
316 .bDescriptorSubtype = USB_MS_MIDI_OUT_JACK,
317 .bJackType = USB_MS_EXTERNAL,
318 .bJackID = JACK_OUT_EXT,
319 .bNrInputPins = 1,
320 .pins = {
321 [0] = {
322 .baSourceID = JACK_IN_EMB,
323 .baSourcePin = 1,
324 }
325 }
326 };
327
328 /* B.5.1 Standard Bulk OUT Endpoint Descriptor */
329 static struct usb_endpoint_descriptor bulk_out_desc = {
330 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
331 .bDescriptorType = USB_DT_ENDPOINT,
332 .bEndpointAddress = USB_DIR_OUT,
333 .bmAttributes = USB_ENDPOINT_XFER_BULK,
334 };
335
336 /* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */
337 static const struct usb_ms_endpoint_descriptor_1 ms_out_desc = {
338 .bLength = USB_DT_MS_ENDPOINT_SIZE(1),
339 .bDescriptorType = USB_DT_CS_ENDPOINT,
340 .bDescriptorSubtype = USB_MS_GENERAL,
341 .bNumEmbMIDIJack = 1,
342 .baAssocJackID = {
343 [0] = JACK_IN_EMB,
344 }
345 };
346
347 /* B.6.1 Standard Bulk IN Endpoint Descriptor */
348 static struct usb_endpoint_descriptor bulk_in_desc = {
349 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
350 .bDescriptorType = USB_DT_ENDPOINT,
351 .bEndpointAddress = USB_DIR_IN,
352 .bmAttributes = USB_ENDPOINT_XFER_BULK,
353 };
354
355 /* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */
356 static const struct usb_ms_endpoint_descriptor_1 ms_in_desc = {
357 .bLength = USB_DT_MS_ENDPOINT_SIZE(1),
358 .bDescriptorType = USB_DT_CS_ENDPOINT,
359 .bDescriptorSubtype = USB_MS_GENERAL,
360 .bNumEmbMIDIJack = 1,
361 .baAssocJackID = {
362 [0] = JACK_OUT_EMB,
363 }
364 };
365
366 static const struct usb_descriptor_header *gmidi_function [] = {
367 (struct usb_descriptor_header *)&ac_interface_desc,
368 (struct usb_descriptor_header *)&ac_header_desc,
369 (struct usb_descriptor_header *)&ms_interface_desc,
370
371 (struct usb_descriptor_header *)&ms_header_desc,
372 (struct usb_descriptor_header *)&jack_in_emb_desc,
373 (struct usb_descriptor_header *)&jack_in_ext_desc,
374 (struct usb_descriptor_header *)&jack_out_emb_desc,
375 (struct usb_descriptor_header *)&jack_out_ext_desc,
376 /* If you add more jacks, update ms_header_desc.wTotalLength */
377
378 (struct usb_descriptor_header *)&bulk_out_desc,
379 (struct usb_descriptor_header *)&ms_out_desc,
380 (struct usb_descriptor_header *)&bulk_in_desc,
381 (struct usb_descriptor_header *)&ms_in_desc,
382 NULL,
383 };
384
385 static char manufacturer[50];
386 static char product_desc[40] = "MIDI Gadget";
387 static char serial_number[20];
388
389 /* static strings, in UTF-8 */
390 static struct usb_string strings [] = {
391 { STRING_MANUFACTURER, manufacturer, },
392 { STRING_PRODUCT, product_desc, },
393 { STRING_SERIAL, serial_number, },
394 { STRING_MIDI_GADGET, longname, },
395 { } /* end of list */
396 };
397
398 static struct usb_gadget_strings stringtab = {
399 .language = 0x0409, /* en-us */
400 .strings = strings,
401 };
402
403 static int config_buf(struct usb_gadget *gadget,
404 u8 *buf, u8 type, unsigned index)
405 {
406 int len;
407
408 /* only one configuration */
409 if (index != 0) {
410 return -EINVAL;
411 }
412 len = usb_gadget_config_buf(&config_desc,
413 buf, USB_BUFSIZ, gmidi_function);
414 if (len < 0) {
415 return len;
416 }
417 ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
418 return len;
419 }
420
421 static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
422 {
423 struct usb_request *req;
424
425 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
426 if (req) {
427 req->length = length;
428 req->buf = kmalloc(length, GFP_ATOMIC);
429 if (!req->buf) {
430 usb_ep_free_request(ep, req);
431 req = NULL;
432 }
433 }
434 return req;
435 }
436
437 static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
438 {
439 kfree(req->buf);
440 usb_ep_free_request(ep, req);
441 }
442
443 static const uint8_t gmidi_cin_length[] = {
444 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
445 };
446
447 /*
448 * Receives a chunk of MIDI data.
449 */
450 static void gmidi_read_data(struct usb_ep *ep, int cable,
451 uint8_t *data, int length)
452 {
453 struct gmidi_device *dev = ep->driver_data;
454 /* cable is ignored, because for now we only have one. */
455
456 if (!dev->out_substream) {
457 /* Nobody is listening - throw it on the floor. */
458 return;
459 }
460 if (!test_bit(dev->out_substream->number, &dev->out_triggered)) {
461 return;
462 }
463 snd_rawmidi_receive(dev->out_substream, data, length);
464 }
465
466 static void gmidi_handle_out_data(struct usb_ep *ep, struct usb_request *req)
467 {
468 unsigned i;
469 u8 *buf = req->buf;
470
471 for (i = 0; i + 3 < req->actual; i += 4) {
472 if (buf[i] != 0) {
473 int cable = buf[i] >> 4;
474 int length = gmidi_cin_length[buf[i] & 0x0f];
475 gmidi_read_data(ep, cable, &buf[i + 1], length);
476 }
477 }
478 }
479
480 static void gmidi_complete(struct usb_ep *ep, struct usb_request *req)
481 {
482 struct gmidi_device *dev = ep->driver_data;
483 int status = req->status;
484
485 switch (status) {
486 case 0: /* normal completion */
487 if (ep == dev->out_ep) {
488 /* we received stuff.
489 req is queued again, below */
490 gmidi_handle_out_data(ep, req);
491 } else if (ep == dev->in_ep) {
492 /* our transmit completed.
493 see if there's more to go.
494 gmidi_transmit eats req, don't queue it again. */
495 gmidi_transmit(dev, req);
496 return;
497 }
498 break;
499
500 /* this endpoint is normally active while we're configured */
501 case -ECONNABORTED: /* hardware forced ep reset */
502 case -ECONNRESET: /* request dequeued */
503 case -ESHUTDOWN: /* disconnect from host */
504 VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status,
505 req->actual, req->length);
506 if (ep == dev->out_ep) {
507 gmidi_handle_out_data(ep, req);
508 }
509 free_ep_req(ep, req);
510 return;
511
512 case -EOVERFLOW: /* buffer overrun on read means that
513 * we didn't provide a big enough
514 * buffer.
515 */
516 default:
517 DBG(dev, "%s complete --> %d, %d/%d\n", ep->name,
518 status, req->actual, req->length);
519 break;
520 case -EREMOTEIO: /* short read */
521 break;
522 }
523
524 status = usb_ep_queue(ep, req, GFP_ATOMIC);
525 if (status) {
526 ERROR(dev, "kill %s: resubmit %d bytes --> %d\n",
527 ep->name, req->length, status);
528 usb_ep_set_halt(ep);
529 /* FIXME recover later ... somehow */
530 }
531 }
532
533 static int set_gmidi_config(struct gmidi_device *dev, gfp_t gfp_flags)
534 {
535 int err = 0;
536 struct usb_request *req;
537 struct usb_ep *ep;
538 unsigned i;
539
540 dev->in_ep->desc = &bulk_in_desc;
541 err = usb_ep_enable(dev->in_ep);
542 if (err) {
543 ERROR(dev, "can't start %s: %d\n", dev->in_ep->name, err);
544 goto fail;
545 }
546 dev->in_ep->driver_data = dev;
547
548 dev->out_ep->desc = &bulk_out_desc;
549 err = usb_ep_enable(dev->out_ep);
550 if (err) {
551 ERROR(dev, "can't start %s: %d\n", dev->out_ep->name, err);
552 goto fail;
553 }
554 dev->out_ep->driver_data = dev;
555
556 /* allocate a bunch of read buffers and queue them all at once. */
557 ep = dev->out_ep;
558 for (i = 0; i < qlen && err == 0; i++) {
559 req = alloc_ep_req(ep, buflen);
560 if (req) {
561 req->complete = gmidi_complete;
562 err = usb_ep_queue(ep, req, GFP_ATOMIC);
563 if (err) {
564 DBG(dev, "%s queue req: %d\n", ep->name, err);
565 }
566 } else {
567 err = -ENOMEM;
568 }
569 }
570 fail:
571 /* caller is responsible for cleanup on error */
572 return err;
573 }
574
575
576 static void gmidi_reset_config(struct gmidi_device *dev)
577 {
578 if (dev->config == 0) {
579 return;
580 }
581
582 DBG(dev, "reset config\n");
583
584 /* just disable endpoints, forcing completion of pending i/o.
585 * all our completion handlers free their requests in this case.
586 */
587 usb_ep_disable(dev->in_ep);
588 usb_ep_disable(dev->out_ep);
589 dev->config = 0;
590 }
591
592 /* change our operational config. this code must agree with the code
593 * that returns config descriptors, and altsetting code.
594 *
595 * it's also responsible for power management interactions. some
596 * configurations might not work with our current power sources.
597 *
598 * note that some device controller hardware will constrain what this
599 * code can do, perhaps by disallowing more than one configuration or
600 * by limiting configuration choices (like the pxa2xx).
601 */
602 static int
603 gmidi_set_config(struct gmidi_device *dev, unsigned number, gfp_t gfp_flags)
604 {
605 int result = 0;
606 struct usb_gadget *gadget = dev->gadget;
607
608 #if 0
609 /* FIXME */
610 /* Hacking this bit out fixes a bug where on receipt of two
611 USB_REQ_SET_CONFIGURATION messages, we end up with no
612 buffered OUT requests waiting for data. This is clearly
613 hiding a bug elsewhere, because if the config didn't
614 change then we really shouldn't do anything. */
615 /* Having said that, when we do "change" from config 1
616 to config 1, we at least gmidi_reset_config() which
617 clears out any requests on endpoints, so it's not like
618 we leak or anything. */
619 if (number == dev->config) {
620 return 0;
621 }
622 #endif
623
624 gmidi_reset_config(dev);
625
626 switch (number) {
627 case GMIDI_CONFIG:
628 result = set_gmidi_config(dev, gfp_flags);
629 break;
630 default:
631 result = -EINVAL;
632 /* FALL THROUGH */
633 case 0:
634 return result;
635 }
636
637 if (!result && (!dev->in_ep || !dev->out_ep)) {
638 result = -ENODEV;
639 }
640 if (result) {
641 gmidi_reset_config(dev);
642 } else {
643 char *speed;
644
645 switch (gadget->speed) {
646 case USB_SPEED_LOW: speed = "low"; break;
647 case USB_SPEED_FULL: speed = "full"; break;
648 case USB_SPEED_HIGH: speed = "high"; break;
649 default: speed = "?"; break;
650 }
651
652 dev->config = number;
653 INFO(dev, "%s speed\n", speed);
654 }
655 return result;
656 }
657
658
659 static void gmidi_setup_complete(struct usb_ep *ep, struct usb_request *req)
660 {
661 if (req->status || req->actual != req->length) {
662 DBG((struct gmidi_device *) ep->driver_data,
663 "setup complete --> %d, %d/%d\n",
664 req->status, req->actual, req->length);
665 }
666 }
667
668 /*
669 * The setup() callback implements all the ep0 functionality that's
670 * not handled lower down, in hardware or the hardware driver (like
671 * device and endpoint feature flags, and their status). It's all
672 * housekeeping for the gadget function we're implementing. Most of
673 * the work is in config-specific setup.
674 */
675 static int gmidi_setup(struct usb_gadget *gadget,
676 const struct usb_ctrlrequest *ctrl)
677 {
678 struct gmidi_device *dev = get_gadget_data(gadget);
679 struct usb_request *req = dev->req;
680 int value = -EOPNOTSUPP;
681 u16 w_index = le16_to_cpu(ctrl->wIndex);
682 u16 w_value = le16_to_cpu(ctrl->wValue);
683 u16 w_length = le16_to_cpu(ctrl->wLength);
684
685 /* usually this stores reply data in the pre-allocated ep0 buffer,
686 * but config change events will reconfigure hardware.
687 */
688 req->zero = 0;
689 switch (ctrl->bRequest) {
690
691 case USB_REQ_GET_DESCRIPTOR:
692 if (ctrl->bRequestType != USB_DIR_IN) {
693 goto unknown;
694 }
695 switch (w_value >> 8) {
696
697 case USB_DT_DEVICE:
698 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
699 value = min(w_length, (u16) sizeof(device_desc));
700 memcpy(req->buf, &device_desc, value);
701 break;
702 case USB_DT_CONFIG:
703 value = config_buf(gadget, req->buf,
704 w_value >> 8,
705 w_value & 0xff);
706 if (value >= 0) {
707 value = min(w_length, (u16)value);
708 }
709 break;
710
711 case USB_DT_STRING:
712 /* wIndex == language code.
713 * this driver only handles one language, you can
714 * add string tables for other languages, using
715 * any UTF-8 characters
716 */
717 value = usb_gadget_get_string(&stringtab,
718 w_value & 0xff, req->buf);
719 if (value >= 0) {
720 value = min(w_length, (u16)value);
721 }
722 break;
723 }
724 break;
725
726 /* currently two configs, two speeds */
727 case USB_REQ_SET_CONFIGURATION:
728 if (ctrl->bRequestType != 0) {
729 goto unknown;
730 }
731 if (gadget->a_hnp_support) {
732 DBG(dev, "HNP available\n");
733 } else if (gadget->a_alt_hnp_support) {
734 DBG(dev, "HNP needs a different root port\n");
735 } else {
736 VDBG(dev, "HNP inactive\n");
737 }
738 spin_lock(&dev->lock);
739 value = gmidi_set_config(dev, w_value, GFP_ATOMIC);
740 spin_unlock(&dev->lock);
741 break;
742 case USB_REQ_GET_CONFIGURATION:
743 if (ctrl->bRequestType != USB_DIR_IN) {
744 goto unknown;
745 }
746 *(u8 *)req->buf = dev->config;
747 value = min(w_length, (u16)1);
748 break;
749
750 /* until we add altsetting support, or other interfaces,
751 * only 0/0 are possible. pxa2xx only supports 0/0 (poorly)
752 * and already killed pending endpoint I/O.
753 */
754 case USB_REQ_SET_INTERFACE:
755 if (ctrl->bRequestType != USB_RECIP_INTERFACE) {
756 goto unknown;
757 }
758 spin_lock(&dev->lock);
759 if (dev->config && w_index < GMIDI_NUM_INTERFACES
760 && w_value == 0)
761 {
762 u8 config = dev->config;
763
764 /* resets interface configuration, forgets about
765 * previous transaction state (queued bufs, etc)
766 * and re-inits endpoint state (toggle etc)
767 * no response queued, just zero status == success.
768 * if we had more than one interface we couldn't
769 * use this "reset the config" shortcut.
770 */
771 gmidi_reset_config(dev);
772 gmidi_set_config(dev, config, GFP_ATOMIC);
773 value = 0;
774 }
775 spin_unlock(&dev->lock);
776 break;
777 case USB_REQ_GET_INTERFACE:
778 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)) {
779 goto unknown;
780 }
781 if (!dev->config) {
782 break;
783 }
784 if (w_index >= GMIDI_NUM_INTERFACES) {
785 value = -EDOM;
786 break;
787 }
788 *(u8 *)req->buf = 0;
789 value = min(w_length, (u16)1);
790 break;
791
792 default:
793 unknown:
794 VDBG(dev, "unknown control req%02x.%02x v%04x i%04x l%d\n",
795 ctrl->bRequestType, ctrl->bRequest,
796 w_value, w_index, w_length);
797 }
798
799 /* respond with data transfer before status phase? */
800 if (value >= 0) {
801 req->length = value;
802 req->zero = value < w_length;
803 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
804 if (value < 0) {
805 DBG(dev, "ep_queue --> %d\n", value);
806 req->status = 0;
807 gmidi_setup_complete(gadget->ep0, req);
808 }
809 }
810
811 /* device either stalls (value < 0) or reports success */
812 return value;
813 }
814
815 static void gmidi_disconnect(struct usb_gadget *gadget)
816 {
817 struct gmidi_device *dev = get_gadget_data(gadget);
818 unsigned long flags;
819
820 spin_lock_irqsave(&dev->lock, flags);
821 gmidi_reset_config(dev);
822
823 /* a more significant application might have some non-usb
824 * activities to quiesce here, saving resources like power
825 * or pushing the notification up a network stack.
826 */
827 spin_unlock_irqrestore(&dev->lock, flags);
828
829 /* next we may get setup() calls to enumerate new connections;
830 * or an unbind() during shutdown (including removing module).
831 */
832 }
833
834 static void /* __init_or_exit */ gmidi_unbind(struct usb_gadget *gadget)
835 {
836 struct gmidi_device *dev = get_gadget_data(gadget);
837 struct snd_card *card;
838
839 DBG(dev, "unbind\n");
840
841 card = dev->card;
842 dev->card = NULL;
843 if (card) {
844 snd_card_free(card);
845 }
846
847 /* we've already been disconnected ... no i/o is active */
848 if (dev->req) {
849 dev->req->length = USB_BUFSIZ;
850 free_ep_req(gadget->ep0, dev->req);
851 }
852 kfree(dev);
853 set_gadget_data(gadget, NULL);
854 }
855
856 static int gmidi_snd_free(struct snd_device *device)
857 {
858 return 0;
859 }
860
861 static void gmidi_transmit_packet(struct usb_request *req, uint8_t p0,
862 uint8_t p1, uint8_t p2, uint8_t p3)
863 {
864 unsigned length = req->length;
865 u8 *buf = (u8 *)req->buf + length;
866
867 buf[0] = p0;
868 buf[1] = p1;
869 buf[2] = p2;
870 buf[3] = p3;
871 req->length = length + 4;
872 }
873
874 /*
875 * Converts MIDI commands to USB MIDI packets.
876 */
877 static void gmidi_transmit_byte(struct usb_request *req,
878 struct gmidi_in_port *port, uint8_t b)
879 {
880 uint8_t p0 = port->cable;
881
882 if (b >= 0xf8) {
883 gmidi_transmit_packet(req, p0 | 0x0f, b, 0, 0);
884 } else if (b >= 0xf0) {
885 switch (b) {
886 case 0xf0:
887 port->data[0] = b;
888 port->state = STATE_SYSEX_1;
889 break;
890 case 0xf1:
891 case 0xf3:
892 port->data[0] = b;
893 port->state = STATE_1PARAM;
894 break;
895 case 0xf2:
896 port->data[0] = b;
897 port->state = STATE_2PARAM_1;
898 break;
899 case 0xf4:
900 case 0xf5:
901 port->state = STATE_UNKNOWN;
902 break;
903 case 0xf6:
904 gmidi_transmit_packet(req, p0 | 0x05, 0xf6, 0, 0);
905 port->state = STATE_UNKNOWN;
906 break;
907 case 0xf7:
908 switch (port->state) {
909 case STATE_SYSEX_0:
910 gmidi_transmit_packet(req,
911 p0 | 0x05, 0xf7, 0, 0);
912 break;
913 case STATE_SYSEX_1:
914 gmidi_transmit_packet(req,
915 p0 | 0x06, port->data[0], 0xf7, 0);
916 break;
917 case STATE_SYSEX_2:
918 gmidi_transmit_packet(req,
919 p0 | 0x07, port->data[0],
920 port->data[1], 0xf7);
921 break;
922 }
923 port->state = STATE_UNKNOWN;
924 break;
925 }
926 } else if (b >= 0x80) {
927 port->data[0] = b;
928 if (b >= 0xc0 && b <= 0xdf)
929 port->state = STATE_1PARAM;
930 else
931 port->state = STATE_2PARAM_1;
932 } else { /* b < 0x80 */
933 switch (port->state) {
934 case STATE_1PARAM:
935 if (port->data[0] < 0xf0) {
936 p0 |= port->data[0] >> 4;
937 } else {
938 p0 |= 0x02;
939 port->state = STATE_UNKNOWN;
940 }
941 gmidi_transmit_packet(req, p0, port->data[0], b, 0);
942 break;
943 case STATE_2PARAM_1:
944 port->data[1] = b;
945 port->state = STATE_2PARAM_2;
946 break;
947 case STATE_2PARAM_2:
948 if (port->data[0] < 0xf0) {
949 p0 |= port->data[0] >> 4;
950 port->state = STATE_2PARAM_1;
951 } else {
952 p0 |= 0x03;
953 port->state = STATE_UNKNOWN;
954 }
955 gmidi_transmit_packet(req,
956 p0, port->data[0], port->data[1], b);
957 break;
958 case STATE_SYSEX_0:
959 port->data[0] = b;
960 port->state = STATE_SYSEX_1;
961 break;
962 case STATE_SYSEX_1:
963 port->data[1] = b;
964 port->state = STATE_SYSEX_2;
965 break;
966 case STATE_SYSEX_2:
967 gmidi_transmit_packet(req,
968 p0 | 0x04, port->data[0], port->data[1], b);
969 port->state = STATE_SYSEX_0;
970 break;
971 }
972 }
973 }
974
975 static void gmidi_transmit(struct gmidi_device *dev, struct usb_request *req)
976 {
977 struct usb_ep *ep = dev->in_ep;
978 struct gmidi_in_port *port = &dev->in_port;
979
980 if (!ep) {
981 return;
982 }
983 if (!req) {
984 req = alloc_ep_req(ep, buflen);
985 }
986 if (!req) {
987 ERROR(dev, "gmidi_transmit: alloc_ep_request failed\n");
988 return;
989 }
990 req->length = 0;
991 req->complete = gmidi_complete;
992
993 if (port->active) {
994 while (req->length + 3 < buflen) {
995 uint8_t b;
996 if (snd_rawmidi_transmit(dev->in_substream, &b, 1)
997 != 1)
998 {
999 port->active = 0;
1000 break;
1001 }
1002 gmidi_transmit_byte(req, port, b);
1003 }
1004 }
1005 if (req->length > 0) {
1006 usb_ep_queue(ep, req, GFP_ATOMIC);
1007 } else {
1008 free_ep_req(ep, req);
1009 }
1010 }
1011
1012 static void gmidi_in_tasklet(unsigned long data)
1013 {
1014 struct gmidi_device *dev = (struct gmidi_device *)data;
1015
1016 gmidi_transmit(dev, NULL);
1017 }
1018
1019 static int gmidi_in_open(struct snd_rawmidi_substream *substream)
1020 {
1021 struct gmidi_device *dev = substream->rmidi->private_data;
1022
1023 VDBG(dev, "gmidi_in_open\n");
1024 dev->in_substream = substream;
1025 dev->in_port.state = STATE_UNKNOWN;
1026 return 0;
1027 }
1028
1029 static int gmidi_in_close(struct snd_rawmidi_substream *substream)
1030 {
1031 struct gmidi_device *dev = substream->rmidi->private_data;
1032
1033 VDBG(dev, "gmidi_in_close\n");
1034 return 0;
1035 }
1036
1037 static void gmidi_in_trigger(struct snd_rawmidi_substream *substream, int up)
1038 {
1039 struct gmidi_device *dev = substream->rmidi->private_data;
1040
1041 VDBG(dev, "gmidi_in_trigger %d\n", up);
1042 dev->in_port.active = up;
1043 if (up) {
1044 tasklet_hi_schedule(&dev->tasklet);
1045 }
1046 }
1047
1048 static int gmidi_out_open(struct snd_rawmidi_substream *substream)
1049 {
1050 struct gmidi_device *dev = substream->rmidi->private_data;
1051
1052 VDBG(dev, "gmidi_out_open\n");
1053 dev->out_substream = substream;
1054 return 0;
1055 }
1056
1057 static int gmidi_out_close(struct snd_rawmidi_substream *substream)
1058 {
1059 struct gmidi_device *dev = substream->rmidi->private_data;
1060
1061 VDBG(dev, "gmidi_out_close\n");
1062 return 0;
1063 }
1064
1065 static void gmidi_out_trigger(struct snd_rawmidi_substream *substream, int up)
1066 {
1067 struct gmidi_device *dev = substream->rmidi->private_data;
1068
1069 VDBG(dev, "gmidi_out_trigger %d\n", up);
1070 if (up) {
1071 set_bit(substream->number, &dev->out_triggered);
1072 } else {
1073 clear_bit(substream->number, &dev->out_triggered);
1074 }
1075 }
1076
1077 static struct snd_rawmidi_ops gmidi_in_ops = {
1078 .open = gmidi_in_open,
1079 .close = gmidi_in_close,
1080 .trigger = gmidi_in_trigger,
1081 };
1082
1083 static struct snd_rawmidi_ops gmidi_out_ops = {
1084 .open = gmidi_out_open,
1085 .close = gmidi_out_close,
1086 .trigger = gmidi_out_trigger
1087 };
1088
1089 /* register as a sound "card" */
1090 static int gmidi_register_card(struct gmidi_device *dev)
1091 {
1092 struct snd_card *card;
1093 struct snd_rawmidi *rmidi;
1094 int err;
1095 int out_ports = 1;
1096 int in_ports = 1;
1097 static struct snd_device_ops ops = {
1098 .dev_free = gmidi_snd_free,
1099 };
1100
1101 err = snd_card_create(index, id, THIS_MODULE, 0, &card);
1102 if (err < 0) {
1103 ERROR(dev, "snd_card_create failed\n");
1104 goto fail;
1105 }
1106 dev->card = card;
1107
1108 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, dev, &ops);
1109 if (err < 0) {
1110 ERROR(dev, "snd_device_new failed: error %d\n", err);
1111 goto fail;
1112 }
1113
1114 strcpy(card->driver, longname);
1115 strcpy(card->longname, longname);
1116 strcpy(card->shortname, shortname);
1117
1118 /* Set up rawmidi */
1119 dev->in_port.dev = dev;
1120 dev->in_port.active = 0;
1121 snd_component_add(card, "MIDI");
1122 err = snd_rawmidi_new(card, "USB MIDI Gadget", 0,
1123 out_ports, in_ports, &rmidi);
1124 if (err < 0) {
1125 ERROR(dev, "snd_rawmidi_new failed: error %d\n", err);
1126 goto fail;
1127 }
1128 dev->rmidi = rmidi;
1129 strcpy(rmidi->name, card->shortname);
1130 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
1131 SNDRV_RAWMIDI_INFO_INPUT |
1132 SNDRV_RAWMIDI_INFO_DUPLEX;
1133 rmidi->private_data = dev;
1134
1135 /* Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT.
1136 It's an upside-down world being a gadget. */
1137 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops);
1138 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops);
1139
1140 snd_card_set_dev(card, &dev->gadget->dev);
1141
1142 /* register it - we're ready to go */
1143 err = snd_card_register(card);
1144 if (err < 0) {
1145 ERROR(dev, "snd_card_register failed\n");
1146 goto fail;
1147 }
1148
1149 VDBG(dev, "gmidi_register_card finished ok\n");
1150 return 0;
1151
1152 fail:
1153 if (dev->card) {
1154 snd_card_free(dev->card);
1155 dev->card = NULL;
1156 }
1157 return err;
1158 }
1159
1160 /*
1161 * Creates an output endpoint, and initializes output ports.
1162 */
1163 static int __init gmidi_bind(struct usb_gadget *gadget)
1164 {
1165 struct gmidi_device *dev;
1166 struct usb_ep *in_ep, *out_ep;
1167 int gcnum, err = 0;
1168
1169 /* support optional vendor/distro customization */
1170 if (idVendor) {
1171 if (!idProduct) {
1172 pr_err("idVendor needs idProduct!\n");
1173 return -ENODEV;
1174 }
1175 device_desc.idVendor = cpu_to_le16(idVendor);
1176 device_desc.idProduct = cpu_to_le16(idProduct);
1177 if (bcdDevice) {
1178 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
1179 }
1180 }
1181 if (iManufacturer) {
1182 strlcpy(manufacturer, iManufacturer, sizeof(manufacturer));
1183 } else {
1184 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
1185 init_utsname()->sysname, init_utsname()->release,
1186 gadget->name);
1187 }
1188 if (iProduct) {
1189 strlcpy(product_desc, iProduct, sizeof(product_desc));
1190 }
1191 if (iSerialNumber) {
1192 device_desc.iSerialNumber = STRING_SERIAL,
1193 strlcpy(serial_number, iSerialNumber, sizeof(serial_number));
1194 }
1195
1196 /* Bulk-only drivers like this one SHOULD be able to
1197 * autoconfigure on any sane usb controller driver,
1198 * but there may also be important quirks to address.
1199 */
1200 usb_ep_autoconfig_reset(gadget);
1201 in_ep = usb_ep_autoconfig(gadget, &bulk_in_desc);
1202 if (!in_ep) {
1203 autoconf_fail:
1204 pr_err("%s: can't autoconfigure on %s\n",
1205 shortname, gadget->name);
1206 return -ENODEV;
1207 }
1208 EP_IN_NAME = in_ep->name;
1209 in_ep->driver_data = in_ep; /* claim */
1210
1211 out_ep = usb_ep_autoconfig(gadget, &bulk_out_desc);
1212 if (!out_ep) {
1213 goto autoconf_fail;
1214 }
1215 EP_OUT_NAME = out_ep->name;
1216 out_ep->driver_data = out_ep; /* claim */
1217
1218 gcnum = usb_gadget_controller_number(gadget);
1219 if (gcnum >= 0) {
1220 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
1221 } else {
1222 /* gmidi is so simple (no altsettings) that
1223 * it SHOULD NOT have problems with bulk-capable hardware.
1224 * so warn about unrecognized controllers, don't panic.
1225 */
1226 pr_warning("%s: controller '%s' not recognized\n",
1227 shortname, gadget->name);
1228 device_desc.bcdDevice = cpu_to_le16(0x9999);
1229 }
1230
1231
1232 /* ok, we made sense of the hardware ... */
1233 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1234 if (!dev) {
1235 return -ENOMEM;
1236 }
1237 spin_lock_init(&dev->lock);
1238 dev->gadget = gadget;
1239 dev->in_ep = in_ep;
1240 dev->out_ep = out_ep;
1241 set_gadget_data(gadget, dev);
1242 tasklet_init(&dev->tasklet, gmidi_in_tasklet, (unsigned long)dev);
1243
1244 /* preallocate control response and buffer */
1245 dev->req = alloc_ep_req(gadget->ep0, USB_BUFSIZ);
1246 if (!dev->req) {
1247 err = -ENOMEM;
1248 goto fail;
1249 }
1250
1251 dev->req->complete = gmidi_setup_complete;
1252
1253 gadget->ep0->driver_data = dev;
1254
1255 INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname);
1256 INFO(dev, "using %s, OUT %s IN %s\n", gadget->name,
1257 EP_OUT_NAME, EP_IN_NAME);
1258
1259 /* register as an ALSA sound card */
1260 err = gmidi_register_card(dev);
1261 if (err < 0) {
1262 goto fail;
1263 }
1264
1265 VDBG(dev, "gmidi_bind finished ok\n");
1266 return 0;
1267
1268 fail:
1269 gmidi_unbind(gadget);
1270 return err;
1271 }
1272
1273
1274 static void gmidi_suspend(struct usb_gadget *gadget)
1275 {
1276 struct gmidi_device *dev = get_gadget_data(gadget);
1277
1278 if (gadget->speed == USB_SPEED_UNKNOWN) {
1279 return;
1280 }
1281
1282 DBG(dev, "suspend\n");
1283 }
1284
1285 static void gmidi_resume(struct usb_gadget *gadget)
1286 {
1287 struct gmidi_device *dev = get_gadget_data(gadget);
1288
1289 DBG(dev, "resume\n");
1290 }
1291
1292
1293 static struct usb_gadget_driver gmidi_driver = {
1294 .speed = USB_SPEED_FULL,
1295 .function = (char *)longname,
1296 .unbind = gmidi_unbind,
1297
1298 .setup = gmidi_setup,
1299 .disconnect = gmidi_disconnect,
1300
1301 .suspend = gmidi_suspend,
1302 .resume = gmidi_resume,
1303
1304 .driver = {
1305 .name = (char *)shortname,
1306 .owner = THIS_MODULE,
1307 },
1308 };
1309
1310 static int __init gmidi_init(void)
1311 {
1312 return usb_gadget_probe_driver(&gmidi_driver, gmidi_bind);
1313 }
1314 module_init(gmidi_init);
1315
1316 static void __exit gmidi_cleanup(void)
1317 {
1318 usb_gadget_unregister_driver(&gmidi_driver);
1319 }
1320 module_exit(gmidi_cleanup);
1321
Linux Btrfs Development