git.oblomov.eu Git - linux-2.6/blob - drivers/usb/gadget/zero.c

   1 /*
   2  * zero.c -- Gadget Zero, for USB development
   3  *
   4  * Copyright (C) 2003-2004 David Brownell
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The names of the above-listed copyright holders may not be used
  17  *    to endorse or promote products derived from this software without
  18  *    specific prior written permission.
  19  *
  20  * ALTERNATIVELY, this software may be distributed under the terms of the
  21  * GNU General Public License ("GPL") as published by the Free Software
  22  * Foundation, either version 2 of that License or (at your option) any
  23  * later version.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  26  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  32  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38
  39 /*
  40  * Gadget Zero only needs two bulk endpoints, and is an example of how you
  41  * can write a hardware-agnostic gadget driver running inside a USB device.
  42  *
  43  * Hardware details are visible (see CONFIG_USB_ZERO_* below) but don't
  44  * affect most of the driver.
  45  *
  46  * Use it with the Linux host/master side "usbtest" driver to get a basic
  47  * functional test of your device-side usb stack, or with "usb-skeleton".
  48  *
  49  * It supports two similar configurations.  One sinks whatever the usb host
  50  * writes, and in return sources zeroes.  The other loops whatever the host
  51  * writes back, so the host can read it.  Module options include:
  52  *
  53  *   buflen=N           default N=4096, buffer size used
  54  *   qlen=N             default N=32, how many buffers in the loopback queue
  55  *   loopdefault        default false, list loopback config first
  56  *
  57  * Many drivers will only have one configuration, letting them be much
  58  * simpler if they also don't support high speed operation (like this
  59  * driver does).
  60  */
  61
  62 #define DEBUG 1
  63 // #define VERBOSE
  64
  65 #include <linux/module.h>
  66 #include <linux/kernel.h>
  67 #include <linux/delay.h>
  68 #include <linux/ioport.h>
  69 #include <linux/slab.h>
  70 #include <linux/errno.h>
  71 #include <linux/init.h>
  72 #include <linux/timer.h>
  73 #include <linux/list.h>
  74 #include <linux/interrupt.h>
  75 #include <linux/utsname.h>
  76 #include <linux/device.h>
  77 #include <linux/moduleparam.h>
  78
  79 #include <asm/byteorder.h>
  80 #include <asm/io.h>
  81 #include <asm/irq.h>
  82 #include <asm/system.h>
  83 #include <asm/unaligned.h>
  84
  85 #include <linux/usb/ch9.h>
  86 #include <linux/usb_gadget.h>
  87
  88 #include "gadget_chips.h"
  89
  90
  91 /*-------------------------------------------------------------------------*/
  92
  93 #define DRIVER_VERSION          "St Patrick's Day 2004"
  94
  95 static const char shortname [] = "zero";
  96 static const char longname [] = "Gadget Zero";
  97
  98 static const char source_sink [] = "source and sink data";
  99 static const char loopback [] = "loop input to output";
 100
 101 /*-------------------------------------------------------------------------*/
 102
 103 /*
 104  * driver assumes self-powered hardware, and
 105  * has no way for users to trigger remote wakeup.
 106  *
 107  * this version autoconfigures as much as possible,
 108  * which is reasonable for most "bulk-only" drivers.
 109  */
 110 static const char *EP_IN_NAME;          /* source */
 111 static const char *EP_OUT_NAME;         /* sink */
 112
 113 /*-------------------------------------------------------------------------*/
 114
 115 /* big enough to hold our biggest descriptor */
 116 #define USB_BUFSIZ      256
 117
 118 struct zero_dev {
 119         spinlock_t              lock;
 120         struct usb_gadget       *gadget;
 121         struct usb_request      *req;           /* for control responses */
 122
 123         /* when configured, we have one of two configs:
 124          * - source data (in to host) and sink it (out from host)
 125          * - or loop it back (out from host back in to host)
 126          */
 127         u8                      config;
 128         struct usb_ep           *in_ep, *out_ep;
 129
 130         /* autoresume timer */
 131         struct timer_list       resume;
 132 };
 133
 134 #define xprintk(d,level,fmt,args...) \
 135         dev_printk(level , &(d)->gadget->dev , fmt , ## args)
 136
 137 #ifdef DEBUG
 138 #define DBG(dev,fmt,args...) \
 139         xprintk(dev , KERN_DEBUG , fmt , ## args)
 140 #else
 141 #define DBG(dev,fmt,args...) \
 142         do { } while (0)
 143 #endif /* DEBUG */
 144
 145 #ifdef VERBOSE
 146 #define VDBG    DBG
 147 #else
 148 #define VDBG(dev,fmt,args...) \
 149         do { } while (0)
 150 #endif /* VERBOSE */
 151
 152 #define ERROR(dev,fmt,args...) \
 153         xprintk(dev , KERN_ERR , fmt , ## args)
 154 #define WARN(dev,fmt,args...) \
 155         xprintk(dev , KERN_WARNING , fmt , ## args)
 156 #define INFO(dev,fmt,args...) \
 157         xprintk(dev , KERN_INFO , fmt , ## args)
 158
 159 /*-------------------------------------------------------------------------*/
 160
 161 static unsigned buflen = 4096;
 162 static unsigned qlen = 32;
 163 static unsigned pattern = 0;
 164
 165 module_param (buflen, uint, S_IRUGO);
 166 module_param (qlen, uint, S_IRUGO);
 167 module_param (pattern, uint, S_IRUGO|S_IWUSR);
 168
 169 /*
 170  * if it's nonzero, autoresume says how many seconds to wait
 171  * before trying to wake up the host after suspend.
 172  */
 173 static unsigned autoresume = 0;
 174 module_param (autoresume, uint, 0);
 175
 176 /*
 177  * Normally the "loopback" configuration is second (index 1) so
 178  * it's not the default.  Here's where to change that order, to
 179  * work better with hosts where config changes are problematic.
 180  * Or controllers (like superh) that only support one config.
 181  */
 182 static int loopdefault = 0;
 183
 184 module_param (loopdefault, bool, S_IRUGO|S_IWUSR);
 185
 186 /*-------------------------------------------------------------------------*/
 187
 188 /* Thanks to NetChip Technologies for donating this product ID.
 189  *
 190  * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
 191  * Instead:  allocate your own, using normal USB-IF procedures.
 192  */
 193 #ifndef CONFIG_USB_ZERO_HNPTEST
 194 #define DRIVER_VENDOR_NUM       0x0525          /* NetChip */
 195 #define DRIVER_PRODUCT_NUM      0xa4a0          /* Linux-USB "Gadget Zero" */
 196 #else
 197 #define DRIVER_VENDOR_NUM       0x1a0a          /* OTG test device IDs */
 198 #define DRIVER_PRODUCT_NUM      0xbadd
 199 #endif
 200
 201 /*-------------------------------------------------------------------------*/
 202
 203 /*
 204  * DESCRIPTORS ... most are static, but strings and (full)
 205  * configuration descriptors are built on demand.
 206  */
 207
 208 #define STRING_MANUFACTURER             25
 209 #define STRING_PRODUCT                  42
 210 #define STRING_SERIAL                   101
 211 #define STRING_SOURCE_SINK              250
 212 #define STRING_LOOPBACK                 251
 213
 214 /*
 215  * This device advertises two configurations; these numbers work
 216  * on a pxa250 as well as more flexible hardware.
 217  */
 218 #define CONFIG_SOURCE_SINK      3
 219 #define CONFIG_LOOPBACK         2
 220
 221 static struct usb_device_descriptor
 222 device_desc = {
 223         .bLength =              sizeof device_desc,
 224         .bDescriptorType =      USB_DT_DEVICE,
 225
 226         .bcdUSB =               __constant_cpu_to_le16 (0x0200),
 227         .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
 228
 229         .idVendor =             __constant_cpu_to_le16 (DRIVER_VENDOR_NUM),
 230         .idProduct =            __constant_cpu_to_le16 (DRIVER_PRODUCT_NUM),
 231         .iManufacturer =        STRING_MANUFACTURER,
 232         .iProduct =             STRING_PRODUCT,
 233         .iSerialNumber =        STRING_SERIAL,
 234         .bNumConfigurations =   2,
 235 };
 236
 237 static struct usb_config_descriptor
 238 source_sink_config = {
 239         .bLength =              sizeof source_sink_config,
 240         .bDescriptorType =      USB_DT_CONFIG,
 241
 242         /* compute wTotalLength on the fly */
 243         .bNumInterfaces =       1,
 244         .bConfigurationValue =  CONFIG_SOURCE_SINK,
 245         .iConfiguration =       STRING_SOURCE_SINK,
 246         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 247         .bMaxPower =            1,      /* self-powered */
 248 };
 249
 250 static struct usb_config_descriptor
 251 loopback_config = {
 252         .bLength =              sizeof loopback_config,
 253         .bDescriptorType =      USB_DT_CONFIG,
 254
 255         /* compute wTotalLength on the fly */
 256         .bNumInterfaces =       1,
 257         .bConfigurationValue =  CONFIG_LOOPBACK,
 258         .iConfiguration =       STRING_LOOPBACK,
 259         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 260         .bMaxPower =            1,      /* self-powered */
 261 };
 262
 263 static struct usb_otg_descriptor
 264 otg_descriptor = {
 265         .bLength =              sizeof otg_descriptor,
 266         .bDescriptorType =      USB_DT_OTG,
 267
 268         .bmAttributes =         USB_OTG_SRP,
 269 };
 270
 271 /* one interface in each configuration */
 272
 273 static const struct usb_interface_descriptor
 274 source_sink_intf = {
 275         .bLength =              sizeof source_sink_intf,
 276         .bDescriptorType =      USB_DT_INTERFACE,
 277
 278         .bNumEndpoints =        2,
 279         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
 280         .iInterface =           STRING_SOURCE_SINK,
 281 };
 282
 283 static const struct usb_interface_descriptor
 284 loopback_intf = {
 285         .bLength =              sizeof loopback_intf,
 286         .bDescriptorType =      USB_DT_INTERFACE,
 287
 288         .bNumEndpoints =        2,
 289         .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
 290         .iInterface =           STRING_LOOPBACK,
 291 };
 292
 293 /* two full speed bulk endpoints; their use is config-dependent */
 294
 295 static struct usb_endpoint_descriptor
 296 fs_source_desc = {
 297         .bLength =              USB_DT_ENDPOINT_SIZE,
 298         .bDescriptorType =      USB_DT_ENDPOINT,
 299
 300         .bEndpointAddress =     USB_DIR_IN,
 301         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 302 };
 303
 304 static struct usb_endpoint_descriptor
 305 fs_sink_desc = {
 306         .bLength =              USB_DT_ENDPOINT_SIZE,
 307         .bDescriptorType =      USB_DT_ENDPOINT,
 308
 309         .bEndpointAddress =     USB_DIR_OUT,
 310         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 311 };
 312
 313 static const struct usb_descriptor_header *fs_source_sink_function [] = {
 314         (struct usb_descriptor_header *) &otg_descriptor,
 315         (struct usb_descriptor_header *) &source_sink_intf,
 316         (struct usb_descriptor_header *) &fs_sink_desc,
 317         (struct usb_descriptor_header *) &fs_source_desc,
 318         NULL,
 319 };
 320
 321 static const struct usb_descriptor_header *fs_loopback_function [] = {
 322         (struct usb_descriptor_header *) &otg_descriptor,
 323         (struct usb_descriptor_header *) &loopback_intf,
 324         (struct usb_descriptor_header *) &fs_sink_desc,
 325         (struct usb_descriptor_header *) &fs_source_desc,
 326         NULL,
 327 };
 328
 329 #ifdef  CONFIG_USB_GADGET_DUALSPEED
 330
 331 /*
 332  * usb 2.0 devices need to expose both high speed and full speed
 333  * descriptors, unless they only run at full speed.
 334  *
 335  * that means alternate endpoint descriptors (bigger packets)
 336  * and a "device qualifier" ... plus more construction options
 337  * for the config descriptor.
 338  */
 339
 340 static struct usb_endpoint_descriptor
 341 hs_source_desc = {
 342         .bLength =              USB_DT_ENDPOINT_SIZE,
 343         .bDescriptorType =      USB_DT_ENDPOINT,
 344
 345         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 346         .wMaxPacketSize =       __constant_cpu_to_le16 (512),
 347 };
 348
 349 static struct usb_endpoint_descriptor
 350 hs_sink_desc = {
 351         .bLength =              USB_DT_ENDPOINT_SIZE,
 352         .bDescriptorType =      USB_DT_ENDPOINT,
 353
 354         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 355         .wMaxPacketSize =       __constant_cpu_to_le16 (512),
 356 };
 357
 358 static struct usb_qualifier_descriptor
 359 dev_qualifier = {
 360         .bLength =              sizeof dev_qualifier,
 361         .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
 362
 363         .bcdUSB =               __constant_cpu_to_le16 (0x0200),
 364         .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
 365
 366         .bNumConfigurations =   2,
 367 };
 368
 369 static const struct usb_descriptor_header *hs_source_sink_function [] = {
 370         (struct usb_descriptor_header *) &otg_descriptor,
 371         (struct usb_descriptor_header *) &source_sink_intf,
 372         (struct usb_descriptor_header *) &hs_source_desc,
 373         (struct usb_descriptor_header *) &hs_sink_desc,
 374         NULL,
 375 };
 376
 377 static const struct usb_descriptor_header *hs_loopback_function [] = {
 378         (struct usb_descriptor_header *) &otg_descriptor,
 379         (struct usb_descriptor_header *) &loopback_intf,
 380         (struct usb_descriptor_header *) &hs_source_desc,
 381         (struct usb_descriptor_header *) &hs_sink_desc,
 382         NULL,
 383 };
 384
 385 /* maxpacket and other transfer characteristics vary by speed. */
 386 #define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
 387
 388 #else
 389
 390 /* if there's no high speed support, maxpacket doesn't change. */
 391 #define ep_desc(g,hs,fs) fs
 392
 393 #endif  /* !CONFIG_USB_GADGET_DUALSPEED */
 394
 395 static char                             manufacturer [50];
 396 static char                             serial [40];
 397
 398 /* static strings, in UTF-8 */
 399 static struct usb_string                strings [] = {
 400         { STRING_MANUFACTURER, manufacturer, },
 401         { STRING_PRODUCT, longname, },
 402         { STRING_SERIAL, serial, },
 403         { STRING_LOOPBACK, loopback, },
 404         { STRING_SOURCE_SINK, source_sink, },
 405         {  }                    /* end of list */
 406 };
 407
 408 static struct usb_gadget_strings        stringtab = {
 409         .language       = 0x0409,       /* en-us */
 410         .strings        = strings,
 411 };
 412
 413 /*
 414  * config descriptors are also handcrafted.  these must agree with code
 415  * that sets configurations, and with code managing interfaces and their
 416  * altsettings.  other complexity may come from:
 417  *
 418  *  - high speed support, including "other speed config" rules
 419  *  - multiple configurations
 420  *  - interfaces with alternate settings
 421  *  - embedded class or vendor-specific descriptors
 422  *
 423  * this handles high speed, and has a second config that could as easily
 424  * have been an alternate interface setting (on most hardware).
 425  *
 426  * NOTE:  to demonstrate (and test) more USB capabilities, this driver
 427  * should include an altsetting to test interrupt transfers, including
 428  * high bandwidth modes at high speed.  (Maybe work like Intel's test
 429  * device?)
 430  */
 431 static int
 432 config_buf (struct usb_gadget *gadget,
 433                 u8 *buf, u8 type, unsigned index)
 434 {
 435         int                             is_source_sink;
 436         int                             len;
 437         const struct usb_descriptor_header **function;
 438 #ifdef CONFIG_USB_GADGET_DUALSPEED
 439         int                             hs = (gadget->speed == USB_SPEED_HIGH);
 440 #endif
 441
 442         /* two configurations will always be index 0 and index 1 */
 443         if (index > 1)
 444                 return -EINVAL;
 445         is_source_sink = loopdefault ? (index == 1) : (index == 0);
 446
 447 #ifdef CONFIG_USB_GADGET_DUALSPEED
 448         if (type == USB_DT_OTHER_SPEED_CONFIG)
 449                 hs = !hs;
 450         if (hs)
 451                 function = is_source_sink
 452                         ? hs_source_sink_function
 453                         : hs_loopback_function;
 454         else
 455 #endif
 456                 function = is_source_sink
 457                         ? fs_source_sink_function
 458                         : fs_loopback_function;
 459
 460         /* for now, don't advertise srp-only devices */
 461         if (!gadget->is_otg)
 462                 function++;
 463
 464         len = usb_gadget_config_buf (is_source_sink
 465                                         ? &source_sink_config
 466                                         : &loopback_config,
 467                         buf, USB_BUFSIZ, function);
 468         if (len < 0)
 469                 return len;
 470         ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
 471         return len;
 472 }
 473
 474 /*-------------------------------------------------------------------------*/
 475
 476 static struct usb_request *
 477 alloc_ep_req (struct usb_ep *ep, unsigned length)
 478 {
 479         struct usb_request      *req;
 480
 481         req = usb_ep_alloc_request (ep, GFP_ATOMIC);
 482         if (req) {
 483                 req->length = length;
 484                 req->buf = kmalloc(length, GFP_ATOMIC);
 485                 if (!req->buf) {
 486                         usb_ep_free_request (ep, req);
 487                         req = NULL;
 488                 }
 489         }
 490         return req;
 491 }
 492
 493 static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
 494 {
 495         kfree(req->buf);
 496         usb_ep_free_request (ep, req);
 497 }
 498
 499 /*-------------------------------------------------------------------------*/
 500
 501 /* optionally require specific source/sink data patterns  */
 502
 503 static int
 504 check_read_data (
 505         struct zero_dev         *dev,
 506         struct usb_ep           *ep,
 507         struct usb_request      *req
 508 )
 509 {
 510         unsigned        i;
 511         u8              *buf = req->buf;
 512
 513         for (i = 0; i < req->actual; i++, buf++) {
 514                 switch (pattern) {
 515                 /* all-zeroes has no synchronization issues */
 516                 case 0:
 517                         if (*buf == 0)
 518                                 continue;
 519                         break;
 520                 /* mod63 stays in sync with short-terminated transfers,
 521                  * or otherwise when host and gadget agree on how large
 522                  * each usb transfer request should be.  resync is done
 523                  * with set_interface or set_config.
 524                  */
 525                 case 1:
 526                         if (*buf == (u8)(i % 63))
 527                                 continue;
 528                         break;
 529                 }
 530                 ERROR (dev, "bad OUT byte, buf [%d] = %d\n", i, *buf);
 531                 usb_ep_set_halt (ep);
 532                 return -EINVAL;
 533         }
 534         return 0;
 535 }
 536
 537 static void
 538 reinit_write_data (
 539         struct zero_dev         *dev,
 540         struct usb_ep           *ep,
 541         struct usb_request      *req
 542 )
 543 {
 544         unsigned        i;
 545         u8              *buf = req->buf;
 546
 547         switch (pattern) {
 548         case 0:
 549                 memset (req->buf, 0, req->length);
 550                 break;
 551         case 1:
 552                 for  (i = 0; i < req->length; i++)
 553                         *buf++ = (u8) (i % 63);
 554                 break;
 555         }
 556 }
 557
 558 /* if there is only one request in the queue, there'll always be an
 559  * irq delay between end of one request and start of the next.
 560  * that prevents using hardware dma queues.
 561  */
 562 static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
 563 {
 564         struct zero_dev *dev = ep->driver_data;
 565         int             status = req->status;
 566
 567         switch (status) {
 568
 569         case 0:                         /* normal completion? */
 570                 if (ep == dev->out_ep) {
 571                         check_read_data (dev, ep, req);
 572                         memset (req->buf, 0x55, req->length);
 573                 } else
 574                         reinit_write_data (dev, ep, req);
 575                 break;
 576
 577         /* this endpoint is normally active while we're configured */
 578         case -ECONNABORTED:             /* hardware forced ep reset */
 579         case -ECONNRESET:               /* request dequeued */
 580         case -ESHUTDOWN:                /* disconnect from host */
 581                 VDBG (dev, "%s gone (%d), %d/%d\n", ep->name, status,
 582                                 req->actual, req->length);
 583                 if (ep == dev->out_ep)
 584                         check_read_data (dev, ep, req);
 585                 free_ep_req (ep, req);
 586                 return;
 587
 588         case -EOVERFLOW:                /* buffer overrun on read means that
 589                                          * we didn't provide a big enough
 590                                          * buffer.
 591                                          */
 592         default:
 593 #if 1
 594                 DBG (dev, "%s complete --> %d, %d/%d\n", ep->name,
 595                                 status, req->actual, req->length);
 596 #endif
 597         case -EREMOTEIO:                /* short read */
 598                 break;
 599         }
 600
 601         status = usb_ep_queue (ep, req, GFP_ATOMIC);
 602         if (status) {
 603                 ERROR (dev, "kill %s:  resubmit %d bytes --> %d\n",
 604                                 ep->name, req->length, status);
 605                 usb_ep_set_halt (ep);
 606                 /* FIXME recover later ... somehow */
 607         }
 608 }
 609
 610 static struct usb_request *
 611 source_sink_start_ep (struct usb_ep *ep, gfp_t gfp_flags)
 612 {
 613         struct usb_request      *req;
 614         int                     status;
 615
 616         req = alloc_ep_req (ep, buflen);
 617         if (!req)
 618                 return NULL;
 619
 620         memset (req->buf, 0, req->length);
 621         req->complete = source_sink_complete;
 622
 623         if (strcmp (ep->name, EP_IN_NAME) == 0)
 624                 reinit_write_data (ep->driver_data, ep, req);
 625         else
 626                 memset (req->buf, 0x55, req->length);
 627
 628         status = usb_ep_queue (ep, req, gfp_flags);
 629         if (status) {
 630                 struct zero_dev *dev = ep->driver_data;
 631
 632                 ERROR (dev, "start %s --> %d\n", ep->name, status);
 633                 free_ep_req (ep, req);
 634                 req = NULL;
 635         }
 636
 637         return req;
 638 }
 639
 640 static int
 641 set_source_sink_config (struct zero_dev *dev, gfp_t gfp_flags)
 642 {
 643         int                     result = 0;
 644         struct usb_ep           *ep;
 645         struct usb_gadget       *gadget = dev->gadget;
 646
 647         gadget_for_each_ep (ep, gadget) {
 648                 const struct usb_endpoint_descriptor    *d;
 649
 650                 /* one endpoint writes (sources) zeroes in (to the host) */
 651                 if (strcmp (ep->name, EP_IN_NAME) == 0) {
 652                         d = ep_desc (gadget, &hs_source_desc, &fs_source_desc);
 653                         result = usb_ep_enable (ep, d);
 654                         if (result == 0) {
 655                                 ep->driver_data = dev;
 656                                 if (source_sink_start_ep (ep, gfp_flags) != 0) {
 657                                         dev->in_ep = ep;
 658                                         continue;
 659                                 }
 660                                 usb_ep_disable (ep);
 661                                 result = -EIO;
 662                         }
 663
 664                 /* one endpoint reads (sinks) anything out (from the host) */
 665                 } else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
 666                         d = ep_desc (gadget, &hs_sink_desc, &fs_sink_desc);
 667                         result = usb_ep_enable (ep, d);
 668                         if (result == 0) {
 669                                 ep->driver_data = dev;
 670                                 if (source_sink_start_ep (ep, gfp_flags) != 0) {
 671                                         dev->out_ep = ep;
 672                                         continue;
 673                                 }
 674                                 usb_ep_disable (ep);
 675                                 result = -EIO;
 676                         }
 677
 678                 /* ignore any other endpoints */
 679                 } else
 680                         continue;
 681
 682                 /* stop on error */
 683                 ERROR (dev, "can't start %s, result %d\n", ep->name, result);
 684                 break;
 685         }
 686         if (result == 0)
 687                 DBG (dev, "buflen %d\n", buflen);
 688
 689         /* caller is responsible for cleanup on error */
 690         return result;
 691 }
 692
 693 /*-------------------------------------------------------------------------*/
 694
 695 static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
 696 {
 697         struct zero_dev *dev = ep->driver_data;
 698         int             status = req->status;
 699
 700         switch (status) {
 701
 702         case 0:                         /* normal completion? */
 703                 if (ep == dev->out_ep) {
 704                         /* loop this OUT packet back IN to the host */
 705                         req->zero = (req->actual < req->length);
 706                         req->length = req->actual;
 707                         status = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
 708                         if (status == 0)
 709                                 return;
 710
 711                         /* "should never get here" */
 712                         ERROR (dev, "can't loop %s to %s: %d\n",
 713                                 ep->name, dev->in_ep->name,
 714                                 status);
 715                 }
 716
 717                 /* queue the buffer for some later OUT packet */
 718                 req->length = buflen;
 719                 status = usb_ep_queue (dev->out_ep, req, GFP_ATOMIC);
 720                 if (status == 0)
 721                         return;
 722
 723                 /* "should never get here" */
 724                 /* FALLTHROUGH */
 725
 726         default:
 727                 ERROR (dev, "%s loop complete --> %d, %d/%d\n", ep->name,
 728                                 status, req->actual, req->length);
 729                 /* FALLTHROUGH */
 730
 731         /* NOTE:  since this driver doesn't maintain an explicit record
 732          * of requests it submitted (just maintains qlen count), we
 733          * rely on the hardware driver to clean up on disconnect or
 734          * endpoint disable.
 735          */
 736         case -ECONNABORTED:             /* hardware forced ep reset */
 737         case -ECONNRESET:               /* request dequeued */
 738         case -ESHUTDOWN:                /* disconnect from host */
 739                 free_ep_req (ep, req);
 740                 return;
 741         }
 742 }
 743
 744 static int
 745 set_loopback_config (struct zero_dev *dev, gfp_t gfp_flags)
 746 {
 747         int                     result = 0;
 748         struct usb_ep           *ep;
 749         struct usb_gadget       *gadget = dev->gadget;
 750
 751         gadget_for_each_ep (ep, gadget) {
 752                 const struct usb_endpoint_descriptor    *d;
 753
 754                 /* one endpoint writes data back IN to the host */
 755                 if (strcmp (ep->name, EP_IN_NAME) == 0) {
 756                         d = ep_desc (gadget, &hs_source_desc, &fs_source_desc);
 757                         result = usb_ep_enable (ep, d);
 758                         if (result == 0) {
 759                                 ep->driver_data = dev;
 760                                 dev->in_ep = ep;
 761                                 continue;
 762                         }
 763
 764                 /* one endpoint just reads OUT packets */
 765                 } else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
 766                         d = ep_desc (gadget, &hs_sink_desc, &fs_sink_desc);
 767                         result = usb_ep_enable (ep, d);
 768                         if (result == 0) {
 769                                 ep->driver_data = dev;
 770                                 dev->out_ep = ep;
 771                                 continue;
 772                         }
 773
 774                 /* ignore any other endpoints */
 775                 } else
 776                         continue;
 777
 778                 /* stop on error */
 779                 ERROR (dev, "can't enable %s, result %d\n", ep->name, result);
 780                 break;
 781         }
 782
 783         /* allocate a bunch of read buffers and queue them all at once.
 784          * we buffer at most 'qlen' transfers; fewer if any need more
 785          * than 'buflen' bytes each.
 786          */
 787         if (result == 0) {
 788                 struct usb_request      *req;
 789                 unsigned                i;
 790
 791                 ep = dev->out_ep;
 792                 for (i = 0; i < qlen && result == 0; i++) {
 793                         req = alloc_ep_req (ep, buflen);
 794                         if (req) {
 795                                 req->complete = loopback_complete;
 796                                 result = usb_ep_queue (ep, req, GFP_ATOMIC);
 797                                 if (result)
 798                                         DBG (dev, "%s queue req --> %d\n",
 799                                                         ep->name, result);
 800                         } else
 801                                 result = -ENOMEM;
 802                 }
 803         }
 804         if (result == 0)
 805                 DBG (dev, "qlen %d, buflen %d\n", qlen, buflen);
 806
 807         /* caller is responsible for cleanup on error */
 808         return result;
 809 }
 810
 811 /*-------------------------------------------------------------------------*/
 812
 813 static void zero_reset_config (struct zero_dev *dev)
 814 {
 815         if (dev->config == 0)
 816                 return;
 817
 818         DBG (dev, "reset config\n");
 819
 820         /* just disable endpoints, forcing completion of pending i/o.
 821          * all our completion handlers free their requests in this case.
 822          */
 823         if (dev->in_ep) {
 824                 usb_ep_disable (dev->in_ep);
 825                 dev->in_ep = NULL;
 826         }
 827         if (dev->out_ep) {
 828                 usb_ep_disable (dev->out_ep);
 829                 dev->out_ep = NULL;
 830         }
 831         dev->config = 0;
 832         del_timer (&dev->resume);
 833 }
 834
 835 /* change our operational config.  this code must agree with the code
 836  * that returns config descriptors, and altsetting code.
 837  *
 838  * it's also responsible for power management interactions. some
 839  * configurations might not work with our current power sources.
 840  *
 841  * note that some device controller hardware will constrain what this
 842  * code can do, perhaps by disallowing more than one configuration or
 843  * by limiting configuration choices (like the pxa2xx).
 844  */
 845 static int
 846 zero_set_config (struct zero_dev *dev, unsigned number, gfp_t gfp_flags)
 847 {
 848         int                     result = 0;
 849         struct usb_gadget       *gadget = dev->gadget;
 850
 851         if (number == dev->config)
 852                 return 0;
 853
 854         if (gadget_is_sa1100 (gadget) && dev->config) {
 855                 /* tx fifo is full, but we can't clear it...*/
 856                 INFO (dev, "can't change configurations\n");
 857                 return -ESPIPE;
 858         }
 859         zero_reset_config (dev);
 860
 861         switch (number) {
 862         case CONFIG_SOURCE_SINK:
 863                 result = set_source_sink_config (dev, gfp_flags);
 864                 break;
 865         case CONFIG_LOOPBACK:
 866                 result = set_loopback_config (dev, gfp_flags);
 867                 break;
 868         default:
 869                 result = -EINVAL;
 870                 /* FALL THROUGH */
 871         case 0:
 872                 return result;
 873         }
 874
 875         if (!result && (!dev->in_ep || !dev->out_ep))
 876                 result = -ENODEV;
 877         if (result)
 878                 zero_reset_config (dev);
 879         else {
 880                 char *speed;
 881
 882                 switch (gadget->speed) {
 883                 case USB_SPEED_LOW:     speed = "low"; break;
 884                 case USB_SPEED_FULL:    speed = "full"; break;
 885                 case USB_SPEED_HIGH:    speed = "high"; break;
 886                 default:                speed = "?"; break;
 887                 }
 888
 889                 dev->config = number;
 890                 INFO (dev, "%s speed config #%d: %s\n", speed, number,
 891                                 (number == CONFIG_SOURCE_SINK)
 892                                         ? source_sink : loopback);
 893         }
 894         return result;
 895 }
 896
 897 /*-------------------------------------------------------------------------*/
 898
 899 static void zero_setup_complete (struct usb_ep *ep, struct usb_request *req)
 900 {
 901         if (req->status || req->actual != req->length)
 902                 DBG ((struct zero_dev *) ep->driver_data,
 903                                 "setup complete --> %d, %d/%d\n",
 904                                 req->status, req->actual, req->length);
 905 }
 906
 907 /*
 908  * The setup() callback implements all the ep0 functionality that's
 909  * not handled lower down, in hardware or the hardware driver (like
 910  * device and endpoint feature flags, and their status).  It's all
 911  * housekeeping for the gadget function we're implementing.  Most of
 912  * the work is in config-specific setup.
 913  */
 914 static int
 915 zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 916 {
 917         struct zero_dev         *dev = get_gadget_data (gadget);
 918         struct usb_request      *req = dev->req;
 919         int                     value = -EOPNOTSUPP;
 920         u16                     w_index = le16_to_cpu(ctrl->wIndex);
 921         u16                     w_value = le16_to_cpu(ctrl->wValue);
 922         u16                     w_length = le16_to_cpu(ctrl->wLength);
 923
 924         /* usually this stores reply data in the pre-allocated ep0 buffer,
 925          * but config change events will reconfigure hardware.
 926          */
 927         req->zero = 0;
 928         switch (ctrl->bRequest) {
 929
 930         case USB_REQ_GET_DESCRIPTOR:
 931                 if (ctrl->bRequestType != USB_DIR_IN)
 932                         goto unknown;
 933                 switch (w_value >> 8) {
 934
 935                 case USB_DT_DEVICE:
 936                         value = min (w_length, (u16) sizeof device_desc);
 937                         memcpy (req->buf, &device_desc, value);
 938                         break;
 939 #ifdef CONFIG_USB_GADGET_DUALSPEED
 940                 case USB_DT_DEVICE_QUALIFIER:
 941                         if (!gadget->is_dualspeed)
 942                                 break;
 943                         value = min (w_length, (u16) sizeof dev_qualifier);
 944                         memcpy (req->buf, &dev_qualifier, value);
 945                         break;
 946
 947                 case USB_DT_OTHER_SPEED_CONFIG:
 948                         if (!gadget->is_dualspeed)
 949                                 break;
 950                         // FALLTHROUGH
 951 #endif /* CONFIG_USB_GADGET_DUALSPEED */
 952                 case USB_DT_CONFIG:
 953                         value = config_buf (gadget, req->buf,
 954                                         w_value >> 8,
 955                                         w_value & 0xff);
 956                         if (value >= 0)
 957                                 value = min (w_length, (u16) value);
 958                         break;
 959
 960                 case USB_DT_STRING:
 961                         /* wIndex == language code.
 962                          * this driver only handles one language, you can
 963                          * add string tables for other languages, using
 964                          * any UTF-8 characters
 965                          */
 966                         value = usb_gadget_get_string (&stringtab,
 967                                         w_value & 0xff, req->buf);
 968                         if (value >= 0)
 969                                 value = min (w_length, (u16) value);
 970                         break;
 971                 }
 972                 break;
 973
 974         /* currently two configs, two speeds */
 975         case USB_REQ_SET_CONFIGURATION:
 976                 if (ctrl->bRequestType != 0)
 977                         goto unknown;
 978                 if (gadget->a_hnp_support)
 979                         DBG (dev, "HNP available\n");
 980                 else if (gadget->a_alt_hnp_support)
 981                         DBG (dev, "HNP needs a different root port\n");
 982                 else
 983                         VDBG (dev, "HNP inactive\n");
 984                 spin_lock (&dev->lock);
 985                 value = zero_set_config (dev, w_value, GFP_ATOMIC);
 986                 spin_unlock (&dev->lock);
 987                 break;
 988         case USB_REQ_GET_CONFIGURATION:
 989                 if (ctrl->bRequestType != USB_DIR_IN)
 990                         goto unknown;
 991                 *(u8 *)req->buf = dev->config;
 992                 value = min (w_length, (u16) 1);
 993                 break;
 994
 995         /* until we add altsetting support, or other interfaces,
 996          * only 0/0 are possible.  pxa2xx only supports 0/0 (poorly)
 997          * and already killed pending endpoint I/O.
 998          */
 999         case USB_REQ_SET_INTERFACE:
1000                 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1001                         goto unknown;
1002                 spin_lock (&dev->lock);
1003                 if (dev->config && w_index == 0 && w_value == 0) {
1004                         u8              config = dev->config;
1005
1006                         /* resets interface configuration, forgets about
1007                          * previous transaction state (queued bufs, etc)
1008                          * and re-inits endpoint state (toggle etc)
1009                          * no response queued, just zero status == success.
1010                          * if we had more than one interface we couldn't
1011                          * use this "reset the config" shortcut.
1012                          */
1013                         zero_reset_config (dev);
1014                         zero_set_config (dev, config, GFP_ATOMIC);
1015                         value = 0;
1016                 }
1017                 spin_unlock (&dev->lock);
1018                 break;
1019         case USB_REQ_GET_INTERFACE:
1020                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1021                         goto unknown;
1022                 if (!dev->config)
1023                         break;
1024                 if (w_index != 0) {
1025                         value = -EDOM;
1026                         break;
1027                 }
1028                 *(u8 *)req->buf = 0;
1029                 value = min (w_length, (u16) 1);
1030                 break;
1031
1032         /*
1033          * These are the same vendor-specific requests supported by
1034          * Intel's USB 2.0 compliance test devices.  We exceed that
1035          * device spec by allowing multiple-packet requests.
1036          */
1037         case 0x5b:      /* control WRITE test -- fill the buffer */
1038                 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
1039                         goto unknown;
1040                 if (w_value || w_index)
1041                         break;
1042                 /* just read that many bytes into the buffer */
1043                 if (w_length > USB_BUFSIZ)
1044                         break;
1045                 value = w_length;
1046                 break;
1047         case 0x5c:      /* control READ test -- return the buffer */
1048                 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
1049                         goto unknown;
1050                 if (w_value || w_index)
1051                         break;
1052                 /* expect those bytes are still in the buffer; send back */
1053                 if (w_length > USB_BUFSIZ
1054                                 || w_length != req->length)
1055                         break;
1056                 value = w_length;
1057                 break;
1058
1059         default:
1060 unknown:
1061                 VDBG (dev,
1062                         "unknown control req%02x.%02x v%04x i%04x l%d\n",
1063                         ctrl->bRequestType, ctrl->bRequest,
1064                         w_value, w_index, w_length);
1065         }
1066
1067         /* respond with data transfer before status phase? */
1068         if (value >= 0) {
1069                 req->length = value;
1070                 req->zero = value < w_length;
1071                 value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
1072                 if (value < 0) {
1073                         DBG (dev, "ep_queue --> %d\n", value);
1074                         req->status = 0;
1075                         zero_setup_complete (gadget->ep0, req);
1076                 }
1077         }
1078
1079         /* device either stalls (value < 0) or reports success */
1080         return value;
1081 }
1082
1083 static void
1084 zero_disconnect (struct usb_gadget *gadget)
1085 {
1086         struct zero_dev         *dev = get_gadget_data (gadget);
1087         unsigned long           flags;
1088
1089         spin_lock_irqsave (&dev->lock, flags);
1090         zero_reset_config (dev);
1091
1092         /* a more significant application might have some non-usb
1093          * activities to quiesce here, saving resources like power
1094          * or pushing the notification up a network stack.
1095          */
1096         spin_unlock_irqrestore (&dev->lock, flags);
1097
1098         /* next we may get setup() calls to enumerate new connections;
1099          * or an unbind() during shutdown (including removing module).
1100          */
1101 }
1102
1103 static void
1104 zero_autoresume (unsigned long _dev)
1105 {
1106         struct zero_dev *dev = (struct zero_dev *) _dev;
1107         int             status;
1108
1109         /* normally the host would be woken up for something
1110          * more significant than just a timer firing...
1111          */
1112         if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
1113                 status = usb_gadget_wakeup (dev->gadget);
1114                 DBG (dev, "wakeup --> %d\n", status);
1115         }
1116 }
1117
1118 /*-------------------------------------------------------------------------*/
1119
1120 static void /* __init_or_exit */
1121 zero_unbind (struct usb_gadget *gadget)
1122 {
1123         struct zero_dev         *dev = get_gadget_data (gadget);
1124
1125         DBG (dev, "unbind\n");
1126
1127         /* we've already been disconnected ... no i/o is active */
1128         if (dev->req) {
1129                 dev->req->length = USB_BUFSIZ;
1130                 free_ep_req (gadget->ep0, dev->req);
1131         }
1132         del_timer_sync (&dev->resume);
1133         kfree (dev);
1134         set_gadget_data (gadget, NULL);
1135 }
1136
1137 static int __init
1138 zero_bind (struct usb_gadget *gadget)
1139 {
1140         struct zero_dev         *dev;
1141         struct usb_ep           *ep;
1142         int                     gcnum;
1143
1144         /* FIXME this can't yet work right with SH ... it has only
1145          * one configuration, numbered one.
1146          */
1147         if (gadget_is_sh(gadget))
1148                 return -ENODEV;
1149
1150         /* Bulk-only drivers like this one SHOULD be able to
1151          * autoconfigure on any sane usb controller driver,
1152          * but there may also be important quirks to address.
1153          */
1154         usb_ep_autoconfig_reset (gadget);
1155         ep = usb_ep_autoconfig (gadget, &fs_source_desc);
1156         if (!ep) {
1157 autoconf_fail:
1158                 printk (KERN_ERR "%s: can't autoconfigure on %s\n",
1159                         shortname, gadget->name);
1160                 return -ENODEV;
1161         }
1162         EP_IN_NAME = ep->name;
1163         ep->driver_data = ep;   /* claim */
1164
1165         ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
1166         if (!ep)
1167                 goto autoconf_fail;
1168         EP_OUT_NAME = ep->name;
1169         ep->driver_data = ep;   /* claim */
1170
1171         gcnum = usb_gadget_controller_number (gadget);
1172         if (gcnum >= 0)
1173                 device_desc.bcdDevice = cpu_to_le16 (0x0200 + gcnum);
1174         else {
1175                 /* gadget zero is so simple (for now, no altsettings) that
1176                  * it SHOULD NOT have problems with bulk-capable hardware.
1177                  * so warn about unrcognized controllers, don't panic.
1178                  *
1179                  * things like configuration and altsetting numbering
1180                  * can need hardware-specific attention though.
1181                  */
1182                 printk (KERN_WARNING "%s: controller '%s' not recognized\n",
1183                         shortname, gadget->name);
1184                 device_desc.bcdDevice = __constant_cpu_to_le16 (0x9999);
1185         }
1186
1187
1188         /* ok, we made sense of the hardware ... */
1189         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1190         if (!dev)
1191                 return -ENOMEM;
1192         spin_lock_init (&dev->lock);
1193         dev->gadget = gadget;
1194         set_gadget_data (gadget, dev);
1195
1196         /* preallocate control response and buffer */
1197         dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
1198         if (!dev->req)
1199                 goto enomem;
1200         dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
1201         if (!dev->req->buf)
1202                 goto enomem;
1203
1204         dev->req->complete = zero_setup_complete;
1205
1206         device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1207
1208 #ifdef CONFIG_USB_GADGET_DUALSPEED
1209         /* assume ep0 uses the same value for both speeds ... */
1210         dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
1211
1212         /* and that all endpoints are dual-speed */
1213         hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
1214         hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
1215 #endif
1216
1217         if (gadget->is_otg) {
1218                 otg_descriptor.bmAttributes |= USB_OTG_HNP,
1219                 source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1220                 loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1221         }
1222
1223         usb_gadget_set_selfpowered (gadget);
1224
1225         init_timer (&dev->resume);
1226         dev->resume.function = zero_autoresume;
1227         dev->resume.data = (unsigned long) dev;
1228         if (autoresume) {
1229                 source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1230                 loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1231         }
1232
1233         gadget->ep0->driver_data = dev;
1234
1235         INFO (dev, "%s, version: " DRIVER_VERSION "\n", longname);
1236         INFO (dev, "using %s, OUT %s IN %s\n", gadget->name,
1237                 EP_OUT_NAME, EP_IN_NAME);
1238
1239         snprintf (manufacturer, sizeof manufacturer, "%s %s with %s",
1240                 init_utsname()->sysname, init_utsname()->release,
1241                 gadget->name);
1242
1243         return 0;
1244
1245 enomem:
1246         zero_unbind (gadget);
1247         return -ENOMEM;
1248 }
1249
1250 /*-------------------------------------------------------------------------*/
1251
1252 static void
1253 zero_suspend (struct usb_gadget *gadget)
1254 {
1255         struct zero_dev         *dev = get_gadget_data (gadget);
1256
1257         if (gadget->speed == USB_SPEED_UNKNOWN)
1258                 return;
1259
1260         if (autoresume) {
1261                 mod_timer (&dev->resume, jiffies + (HZ * autoresume));
1262                 DBG (dev, "suspend, wakeup in %d seconds\n", autoresume);
1263         } else
1264                 DBG (dev, "suspend\n");
1265 }
1266
1267 static void
1268 zero_resume (struct usb_gadget *gadget)
1269 {
1270         struct zero_dev         *dev = get_gadget_data (gadget);
1271
1272         DBG (dev, "resume\n");
1273         del_timer (&dev->resume);
1274 }
1275
1276
1277 /*-------------------------------------------------------------------------*/
1278
1279 static struct usb_gadget_driver zero_driver = {
1280 #ifdef CONFIG_USB_GADGET_DUALSPEED
1281         .speed          = USB_SPEED_HIGH,
1282 #else
1283         .speed          = USB_SPEED_FULL,
1284 #endif
1285         .function       = (char *) longname,
1286         .bind           = zero_bind,
1287         .unbind         = __exit_p(zero_unbind),
1288
1289         .setup          = zero_setup,
1290         .disconnect     = zero_disconnect,
1291
1292         .suspend        = zero_suspend,
1293         .resume         = zero_resume,
1294
1295         .driver         = {
1296                 .name           = (char *) shortname,
1297                 .owner          = THIS_MODULE,
1298         },
1299 };
1300
1301 MODULE_AUTHOR ("David Brownell");
1302 MODULE_LICENSE ("Dual BSD/GPL");
1303
1304
1305 static int __init init (void)
1306 {
1307         /* a real value would likely come through some id prom
1308          * or module option.  this one takes at least two packets.
1309          */
1310         strlcpy (serial, "0123456789.0123456789.0123456789", sizeof serial);
1311
1312         return usb_gadget_register_driver (&zero_driver);
1313 }
1314 module_init (init);
1315
1316 static void __exit cleanup (void)
1317 {
1318         usb_gadget_unregister_driver (&zero_driver);
1319 }
1320 module_exit (cleanup);
1321