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