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