target/linux/ramips/files-3.7/drivers/usb/dwc_otg/dummy_audio.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 #include <linux/config.h>
  63 #include <linux/module.h>
  64 #include <linux/kernel.h>
  65 #include <linux/delay.h>
  66 #include <linux/ioport.h>
  67 #include <linux/sched.h>
  68 #include <linux/slab.h>
  69 #include <linux/smp_lock.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/uts.h>
  76 #include <linux/version.h>
  77 #include <linux/device.h>
  78 #include <linux/moduleparam.h>
  79 #include <linux/proc_fs.h>
  80
  81 #include <asm/byteorder.h>
  82 #include <asm/io.h>
  83 #include <asm/irq.h>
  84 #include <asm/system.h>
  85 #include <asm/unaligned.h>
  86
  87 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
  88 # include <linux/usb/ch9.h>
  89 #else
  90 # include <linux/usb_ch9.h>
  91 #endif
  92
  93 #include <linux/usb_gadget.h>
  94
  95
  96 /*-------------------------------------------------------------------------*/
  97 /*-------------------------------------------------------------------------*/
  98
  99
 100 static int utf8_to_utf16le(const char *s, u16 *cp, unsigned len)
 101 {
 102         int     count = 0;
 103         u8      c;
 104         u16     uchar;
 105
 106         /* this insists on correct encodings, though not minimal ones.
 107          * BUT it currently rejects legit 4-byte UTF-8 code points,
 108          * which need surrogate pairs.  (Unicode 3.1 can use them.)
 109          */
 110         while (len != 0 && (c = (u8) *s++) != 0) {
 111                 if (unlikely(c & 0x80)) {
 112                         // 2-byte sequence:
 113                         // 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
 114                         if ((c & 0xe0) == 0xc0) {
 115                                 uchar = (c & 0x1f) << 6;
 116
 117                                 c = (u8) *s++;
 118                                 if ((c & 0xc0) != 0xc0)
 119                                         goto fail;
 120                                 c &= 0x3f;
 121                                 uchar |= c;
 122
 123                         // 3-byte sequence (most CJKV characters):
 124                         // zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
 125                         } else if ((c & 0xf0) == 0xe0) {
 126                                 uchar = (c & 0x0f) << 12;
 127
 128                                 c = (u8) *s++;
 129                                 if ((c & 0xc0) != 0xc0)
 130                                         goto fail;
 131                                 c &= 0x3f;
 132                                 uchar |= c << 6;
 133
 134                                 c = (u8) *s++;
 135                                 if ((c & 0xc0) != 0xc0)
 136                                         goto fail;
 137                                 c &= 0x3f;
 138                                 uchar |= c;
 139
 140                                 /* no bogus surrogates */
 141                                 if (0xd800 <= uchar && uchar <= 0xdfff)
 142                                         goto fail;
 143
 144                         // 4-byte sequence (surrogate pairs, currently rare):
 145                         // 11101110wwwwzzzzyy + 110111yyyyxxxxxx
 146                         //     = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
 147                         // (uuuuu = wwww + 1)
 148                         // FIXME accept the surrogate code points (only)
 149
 150                         } else
 151                                 goto fail;
 152                 } else
 153                         uchar = c;
 154                 put_unaligned (cpu_to_le16 (uchar), cp++);
 155                 count++;
 156                 len--;
 157         }
 158         return count;
 159 fail:
 160         return -1;
 161 }
 162
 163
 164 /**
 165  * usb_gadget_get_string - fill out a string descriptor
 166  * @table: of c strings encoded using UTF-8
 167  * @id: string id, from low byte of wValue in get string descriptor
 168  * @buf: at least 256 bytes
 169  *
 170  * Finds the UTF-8 string matching the ID, and converts it into a
 171  * string descriptor in utf16-le.
 172  * Returns length of descriptor (always even) or negative errno
 173  *
 174  * If your driver needs stings in multiple languages, you'll probably
 175  * "switch (wIndex) { ... }"  in your ep0 string descriptor logic,
 176  * using this routine after choosing which set of UTF-8 strings to use.
 177  * Note that US-ASCII is a strict subset of UTF-8; any string bytes with
 178  * the eighth bit set will be multibyte UTF-8 characters, not ISO-8859/1
 179  * characters (which are also widely used in C strings).
 180  */
 181 int
 182 usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
 183 {
 184         struct usb_string       *s;
 185         int                     len;
 186
 187         /* descriptor 0 has the language id */
 188         if (id == 0) {
 189                 buf [0] = 4;
 190                 buf [1] = USB_DT_STRING;
 191                 buf [2] = (u8) table->language;
 192                 buf [3] = (u8) (table->language >> 8);
 193                 return 4;
 194         }
 195         for (s = table->strings; s && s->s; s++)
 196                 if (s->id == id)
 197                         break;
 198
 199         /* unrecognized: stall. */
 200         if (!s || !s->s)
 201                 return -EINVAL;
 202
 203         /* string descriptors have length, tag, then UTF16-LE text */
 204         len = min ((size_t) 126, strlen (s->s));
 205         memset (buf + 2, 0, 2 * len);   /* zero all the bytes */
 206         len = utf8_to_utf16le(s->s, (u16 *)&buf[2], len);
 207         if (len < 0)
 208                 return -EINVAL;
 209         buf [0] = (len + 1) * 2;
 210         buf [1] = USB_DT_STRING;
 211         return buf [0];
 212 }
 213
 214
 215 /*-------------------------------------------------------------------------*/
 216 /*-------------------------------------------------------------------------*/
 217
 218
 219 /**
 220  * usb_descriptor_fillbuf - fill buffer with descriptors
 221  * @buf: Buffer to be filled
 222  * @buflen: Size of buf
 223  * @src: Array of descriptor pointers, terminated by null pointer.
 224  *
 225  * Copies descriptors into the buffer, returning the length or a
 226  * negative error code if they can't all be copied.  Useful when
 227  * assembling descriptors for an associated set of interfaces used
 228  * as part of configuring a composite device; or in other cases where
 229  * sets of descriptors need to be marshaled.
 230  */
 231 int
 232 usb_descriptor_fillbuf(void *buf, unsigned buflen,
 233                 const struct usb_descriptor_header **src)
 234 {
 235         u8      *dest = buf;
 236
 237         if (!src)
 238                 return -EINVAL;
 239
 240         /* fill buffer from src[] until null descriptor ptr */
 241         for (; 0 != *src; src++) {
 242                 unsigned                len = (*src)->bLength;
 243
 244                 if (len > buflen)
 245                         return -EINVAL;
 246                 memcpy(dest, *src, len);
 247                 buflen -= len;
 248                 dest += len;
 249         }
 250         return dest - (u8 *)buf;
 251 }
 252
 253
 254 /**
 255  * usb_gadget_config_buf - builts a complete configuration descriptor
 256  * @config: Header for the descriptor, including characteristics such
 257  *      as power requirements and number of interfaces.
 258  * @desc: Null-terminated vector of pointers to the descriptors (interface,
 259  *      endpoint, etc) defining all functions in this device configuration.
 260  * @buf: Buffer for the resulting configuration descriptor.
 261  * @length: Length of buffer.  If this is not big enough to hold the
 262  *      entire configuration descriptor, an error code will be returned.
 263  *
 264  * This copies descriptors into the response buffer, building a descriptor
 265  * for that configuration.  It returns the buffer length or a negative
 266  * status code.  The config.wTotalLength field is set to match the length
 267  * of the result, but other descriptor fields (including power usage and
 268  * interface count) must be set by the caller.
 269  *
 270  * Gadget drivers could use this when constructing a config descriptor
 271  * in response to USB_REQ_GET_DESCRIPTOR.  They will need to patch the
 272  * resulting bDescriptorType value if USB_DT_OTHER_SPEED_CONFIG is needed.
 273  */
 274 int usb_gadget_config_buf(
 275         const struct usb_config_descriptor      *config,
 276         void                                    *buf,
 277         unsigned                                length,
 278         const struct usb_descriptor_header      **desc
 279 )
 280 {
 281         struct usb_config_descriptor            *cp = buf;
 282         int                                     len;
 283
 284         /* config descriptor first */
 285         if (length < USB_DT_CONFIG_SIZE || !desc)
 286                 return -EINVAL;
 287         *cp = *config;
 288
 289         /* then interface/endpoint/class/vendor/... */
 290         len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf,
 291                         length - USB_DT_CONFIG_SIZE, desc);
 292         if (len < 0)
 293                 return len;
 294         len += USB_DT_CONFIG_SIZE;
 295         if (len > 0xffff)
 296                 return -EINVAL;
 297
 298         /* patch up the config descriptor */
 299         cp->bLength = USB_DT_CONFIG_SIZE;
 300         cp->bDescriptorType = USB_DT_CONFIG;
 301         cp->wTotalLength = cpu_to_le16(len);
 302         cp->bmAttributes |= USB_CONFIG_ATT_ONE;
 303         return len;
 304 }
 305
 306 /*-------------------------------------------------------------------------*/
 307 /*-------------------------------------------------------------------------*/
 308
 309
 310 #define RBUF_LEN (1024*1024)
 311 static int rbuf_start;
 312 static int rbuf_len;
 313 static __u8 rbuf[RBUF_LEN];
 314
 315 /*-------------------------------------------------------------------------*/
 316
 317 #define DRIVER_VERSION          "St Patrick's Day 2004"
 318
 319 static const char shortname [] = "zero";
 320 static const char longname [] = "YAMAHA YST-MS35D USB Speaker  ";
 321
 322 static const char source_sink [] = "source and sink data";
 323 static const char loopback [] = "loop input to output";
 324
 325 /*-------------------------------------------------------------------------*/
 326
 327 /*
 328  * driver assumes self-powered hardware, and
 329  * has no way for users to trigger remote wakeup.
 330  *
 331  * this version autoconfigures as much as possible,
 332  * which is reasonable for most "bulk-only" drivers.
 333  */
 334 static const char *EP_IN_NAME;          /* source */
 335 static const char *EP_OUT_NAME;         /* sink */
 336
 337 /*-------------------------------------------------------------------------*/
 338
 339 /* big enough to hold our biggest descriptor */
 340 #define USB_BUFSIZ      512
 341
 342 struct zero_dev {
 343         spinlock_t              lock;
 344         struct usb_gadget       *gadget;
 345         struct usb_request      *req;           /* for control responses */
 346
 347         /* when configured, we have one of two configs:
 348          * - source data (in to host) and sink it (out from host)
 349          * - or loop it back (out from host back in to host)
 350          */
 351         u8                      config;
 352         struct usb_ep           *in_ep, *out_ep;
 353
 354         /* autoresume timer */
 355         struct timer_list       resume;
 356 };
 357
 358 #define xprintk(d,level,fmt,args...) \
 359         dev_printk(level , &(d)->gadget->dev , fmt , ## args)
 360
 361 #ifdef DEBUG
 362 #define DBG(dev,fmt,args...) \
 363         xprintk(dev , KERN_DEBUG , fmt , ## args)
 364 #else
 365 #define DBG(dev,fmt,args...) \
 366         do { } while (0)
 367 #endif /* DEBUG */
 368
 369 #ifdef VERBOSE
 370 #define VDBG    DBG
 371 #else
 372 #define VDBG(dev,fmt,args...) \
 373         do { } while (0)
 374 #endif /* VERBOSE */
 375
 376 #define ERROR(dev,fmt,args...) \
 377         xprintk(dev , KERN_ERR , fmt , ## args)
 378 #define WARN(dev,fmt,args...) \
 379         xprintk(dev , KERN_WARNING , fmt , ## args)
 380 #define INFO(dev,fmt,args...) \
 381         xprintk(dev , KERN_INFO , fmt , ## args)
 382
 383 /*-------------------------------------------------------------------------*/
 384
 385 static unsigned buflen = 4096;
 386 static unsigned qlen = 32;
 387 static unsigned pattern = 0;
 388
 389 module_param (buflen, uint, S_IRUGO|S_IWUSR);
 390 module_param (qlen, uint, S_IRUGO|S_IWUSR);
 391 module_param (pattern, uint, S_IRUGO|S_IWUSR);
 392
 393 /*
 394  * if it's nonzero, autoresume says how many seconds to wait
 395  * before trying to wake up the host after suspend.
 396  */
 397 static unsigned autoresume = 0;
 398 module_param (autoresume, uint, 0);
 399
 400 /*
 401  * Normally the "loopback" configuration is second (index 1) so
 402  * it's not the default.  Here's where to change that order, to
 403  * work better with hosts where config changes are problematic.
 404  * Or controllers (like superh) that only support one config.
 405  */
 406 static int loopdefault = 0;
 407
 408 module_param (loopdefault, bool, S_IRUGO|S_IWUSR);
 409
 410 /*-------------------------------------------------------------------------*/
 411
 412 /* Thanks to NetChip Technologies for donating this product ID.
 413  *
 414  * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
 415  * Instead:  allocate your own, using normal USB-IF procedures.
 416  */
 417 #ifndef CONFIG_USB_ZERO_HNPTEST
 418 #define DRIVER_VENDOR_NUM       0x0525          /* NetChip */
 419 #define DRIVER_PRODUCT_NUM      0xa4a0          /* Linux-USB "Gadget Zero" */
 420 #else
 421 #define DRIVER_VENDOR_NUM       0x1a0a          /* OTG test device IDs */
 422 #define DRIVER_PRODUCT_NUM      0xbadd
 423 #endif
 424
 425 /*-------------------------------------------------------------------------*/
 426
 427 /*
 428  * DESCRIPTORS ... most are static, but strings and (full)
 429  * configuration descriptors are built on demand.
 430  */
 431
 432 /*
 433 #define STRING_MANUFACTURER             25
 434 #define STRING_PRODUCT                  42
 435 #define STRING_SERIAL                   101
 436 */
 437 #define STRING_MANUFACTURER             1
 438 #define STRING_PRODUCT                  2
 439 #define STRING_SERIAL                   3
 440
 441 #define STRING_SOURCE_SINK              250
 442 #define STRING_LOOPBACK                 251
 443
 444 /*
 445  * This device advertises two configurations; these numbers work
 446  * on a pxa250 as well as more flexible hardware.
 447  */
 448 #define CONFIG_SOURCE_SINK      3
 449 #define CONFIG_LOOPBACK         2
 450
 451 /*
 452 static struct usb_device_descriptor
 453 device_desc = {
 454         .bLength =              sizeof device_desc,
 455         .bDescriptorType =      USB_DT_DEVICE,
 456
 457         .bcdUSB =               __constant_cpu_to_le16 (0x0200),
 458         .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
 459
 460         .idVendor =             __constant_cpu_to_le16 (DRIVER_VENDOR_NUM),
 461         .idProduct =            __constant_cpu_to_le16 (DRIVER_PRODUCT_NUM),
 462         .iManufacturer =        STRING_MANUFACTURER,
 463         .iProduct =             STRING_PRODUCT,
 464         .iSerialNumber =        STRING_SERIAL,
 465         .bNumConfigurations =   2,
 466 };
 467 */
 468 static struct usb_device_descriptor
 469 device_desc = {
 470         .bLength =              sizeof device_desc,
 471         .bDescriptorType =      USB_DT_DEVICE,
 472         .bcdUSB =               __constant_cpu_to_le16 (0x0100),
 473         .bDeviceClass =         USB_CLASS_PER_INTERFACE,
 474         .bDeviceSubClass =      0,
 475         .bDeviceProtocol =      0,
 476         .bMaxPacketSize0 =      64,
 477         .bcdDevice =            __constant_cpu_to_le16 (0x0100),
 478         .idVendor =             __constant_cpu_to_le16 (0x0499),
 479         .idProduct =            __constant_cpu_to_le16 (0x3002),
 480         .iManufacturer =        STRING_MANUFACTURER,
 481         .iProduct =             STRING_PRODUCT,
 482         .iSerialNumber =        STRING_SERIAL,
 483         .bNumConfigurations =   1,
 484 };
 485
 486 static struct usb_config_descriptor
 487 z_config = {
 488         .bLength =              sizeof z_config,
 489         .bDescriptorType =      USB_DT_CONFIG,
 490
 491         /* compute wTotalLength on the fly */
 492         .bNumInterfaces =       2,
 493         .bConfigurationValue =  1,
 494         .iConfiguration =       0,
 495         .bmAttributes =         0x40,
 496         .bMaxPower =            0,      /* self-powered */
 497 };
 498
 499
 500 static struct usb_otg_descriptor
 501 otg_descriptor = {
 502         .bLength =              sizeof otg_descriptor,
 503         .bDescriptorType =      USB_DT_OTG,
 504
 505         .bmAttributes =         USB_OTG_SRP,
 506 };
 507
 508 /* one interface in each configuration */
 509 #ifdef  CONFIG_USB_GADGET_DUALSPEED
 510
 511 /*
 512  * usb 2.0 devices need to expose both high speed and full speed
 513  * descriptors, unless they only run at full speed.
 514  *
 515  * that means alternate endpoint descriptors (bigger packets)
 516  * and a "device qualifier" ... plus more construction options
 517  * for the config descriptor.
 518  */
 519
 520 static struct usb_qualifier_descriptor
 521 dev_qualifier = {
 522         .bLength =              sizeof dev_qualifier,
 523         .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
 524
 525         .bcdUSB =               __constant_cpu_to_le16 (0x0200),
 526         .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
 527
 528         .bNumConfigurations =   2,
 529 };
 530
 531
 532 struct usb_cs_as_general_descriptor {
 533         __u8  bLength;
 534         __u8  bDescriptorType;
 535
 536         __u8  bDescriptorSubType;
 537         __u8  bTerminalLink;
 538         __u8  bDelay;
 539         __u16  wFormatTag;
 540 } __attribute__ ((packed));
 541
 542 struct usb_cs_as_format_descriptor {
 543         __u8  bLength;
 544         __u8  bDescriptorType;
 545
 546         __u8  bDescriptorSubType;
 547         __u8  bFormatType;
 548         __u8  bNrChannels;
 549         __u8  bSubframeSize;
 550         __u8  bBitResolution;
 551         __u8  bSamfreqType;
 552         __u8  tLowerSamFreq[3];
 553         __u8  tUpperSamFreq[3];
 554 } __attribute__ ((packed));
 555
 556 static const struct usb_interface_descriptor
 557 z_audio_control_if_desc = {
 558         .bLength =              sizeof z_audio_control_if_desc,
 559         .bDescriptorType =      USB_DT_INTERFACE,
 560         .bInterfaceNumber = 0,
 561         .bAlternateSetting = 0,
 562         .bNumEndpoints = 0,
 563         .bInterfaceClass = USB_CLASS_AUDIO,
 564         .bInterfaceSubClass = 0x1,
 565         .bInterfaceProtocol = 0,
 566         .iInterface = 0,
 567 };
 568
 569 static const struct usb_interface_descriptor
 570 z_audio_if_desc = {
 571         .bLength =              sizeof z_audio_if_desc,
 572         .bDescriptorType =      USB_DT_INTERFACE,
 573         .bInterfaceNumber = 1,
 574         .bAlternateSetting = 0,
 575         .bNumEndpoints = 0,
 576         .bInterfaceClass = USB_CLASS_AUDIO,
 577         .bInterfaceSubClass = 0x2,
 578         .bInterfaceProtocol = 0,
 579         .iInterface = 0,
 580 };
 581
 582 static const struct usb_interface_descriptor
 583 z_audio_if_desc2 = {
 584         .bLength =              sizeof z_audio_if_desc,
 585         .bDescriptorType =      USB_DT_INTERFACE,
 586         .bInterfaceNumber = 1,
 587         .bAlternateSetting = 1,
 588         .bNumEndpoints = 1,
 589         .bInterfaceClass = USB_CLASS_AUDIO,
 590         .bInterfaceSubClass = 0x2,
 591         .bInterfaceProtocol = 0,
 592         .iInterface = 0,
 593 };
 594
 595 static const struct usb_cs_as_general_descriptor
 596 z_audio_cs_as_if_desc = {
 597         .bLength = 7,
 598         .bDescriptorType = 0x24,
 599
 600         .bDescriptorSubType = 0x01,
 601         .bTerminalLink = 0x01,
 602         .bDelay = 0x0,
 603         .wFormatTag = __constant_cpu_to_le16 (0x0001)
 604 };
 605
 606
 607 static const struct usb_cs_as_format_descriptor
 608 z_audio_cs_as_format_desc = {
 609         .bLength = 0xe,
 610         .bDescriptorType = 0x24,
 611
 612         .bDescriptorSubType = 2,
 613         .bFormatType = 1,
 614         .bNrChannels = 1,
 615         .bSubframeSize = 1,
 616         .bBitResolution = 8,
 617         .bSamfreqType = 0,
 618         .tLowerSamFreq = {0x7e, 0x13, 0x00},
 619         .tUpperSamFreq = {0xe2, 0xd6, 0x00},
 620 };
 621
 622 static const struct usb_endpoint_descriptor
 623 z_iso_ep = {
 624         .bLength = 0x09,
 625         .bDescriptorType = 0x05,
 626         .bEndpointAddress = 0x04,
 627         .bmAttributes = 0x09,
 628         .wMaxPacketSize = 0x0038,
 629         .bInterval = 0x01,
 630         .bRefresh = 0x00,
 631         .bSynchAddress = 0x00,
 632 };
 633
 634 static char z_iso_ep2[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};
 635
 636 // 9 bytes
 637 static char z_ac_interface_header_desc[] =
 638 { 0x09, 0x24, 0x01, 0x00, 0x01, 0x2b, 0x00, 0x01, 0x01 };
 639
 640 // 12 bytes
 641 static char z_0[] = {0x0c, 0x24, 0x02, 0x01, 0x01, 0x01, 0x00, 0x02,
 642                      0x03, 0x00, 0x00, 0x00};
 643 // 13 bytes
 644 static char z_1[] = {0x0d, 0x24, 0x06, 0x02, 0x01, 0x02, 0x15, 0x00,
 645                      0x02, 0x00, 0x02, 0x00, 0x00};
 646 // 9 bytes
 647 static char z_2[] = {0x09, 0x24, 0x03, 0x03, 0x01, 0x03, 0x00, 0x02,
 648                      0x00};
 649
 650 static char za_0[] = {0x09, 0x04, 0x01, 0x02, 0x01, 0x01, 0x02, 0x00,
 651                       0x00};
 652
 653 static char za_1[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};
 654
 655 static char za_2[] = {0x0e, 0x24, 0x02, 0x01, 0x02, 0x01, 0x08, 0x00,
 656                       0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};
 657
 658 static char za_3[] = {0x09, 0x05, 0x04, 0x09, 0x70, 0x00, 0x01, 0x00,
 659                       0x00};
 660
 661 static char za_4[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};
 662
 663 static char za_5[] = {0x09, 0x04, 0x01, 0x03, 0x01, 0x01, 0x02, 0x00,
 664                       0x00};
 665
 666 static char za_6[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};
 667
 668 static char za_7[] = {0x0e, 0x24, 0x02, 0x01, 0x01, 0x02, 0x10, 0x00,
 669                       0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};
 670
 671 static char za_8[] = {0x09, 0x05, 0x04, 0x09, 0x70, 0x00, 0x01, 0x00,
 672                       0x00};
 673
 674 static char za_9[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};
 675
 676 static char za_10[] = {0x09, 0x04, 0x01, 0x04, 0x01, 0x01, 0x02, 0x00,
 677                        0x00};
 678
 679 static char za_11[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};
 680
 681 static char za_12[] = {0x0e, 0x24, 0x02, 0x01, 0x02, 0x02, 0x10, 0x00,
 682                        0x73, 0x13, 0x00, 0xe2, 0xd6, 0x00};
 683
 684 static char za_13[] = {0x09, 0x05, 0x04, 0x09, 0xe0, 0x00, 0x01, 0x00,
 685                        0x00};
 686
 687 static char za_14[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};
 688
 689 static char za_15[] = {0x09, 0x04, 0x01, 0x05, 0x01, 0x01, 0x02, 0x00,
 690                        0x00};
 691
 692 static char za_16[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};
 693
 694 static char za_17[] = {0x0e, 0x24, 0x02, 0x01, 0x01, 0x03, 0x14, 0x00,
 695                        0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};
 696
 697 static char za_18[] = {0x09, 0x05, 0x04, 0x09, 0xa8, 0x00, 0x01, 0x00,
 698                        0x00};
 699
 700 static char za_19[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};
 701
 702 static char za_20[] = {0x09, 0x04, 0x01, 0x06, 0x01, 0x01, 0x02, 0x00,
 703                        0x00};
 704
 705 static char za_21[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};
 706
 707 static char za_22[] = {0x0e, 0x24, 0x02, 0x01, 0x02, 0x03, 0x14, 0x00,
 708                        0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};
 709
 710 static char za_23[] = {0x09, 0x05, 0x04, 0x09, 0x50, 0x01, 0x01, 0x00,
 711                        0x00};
 712
 713 static char za_24[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};
 714
 715
 716
 717 static const struct usb_descriptor_header *z_function [] = {
 718         (struct usb_descriptor_header *) &z_audio_control_if_desc,
 719         (struct usb_descriptor_header *) &z_ac_interface_header_desc,
 720         (struct usb_descriptor_header *) &z_0,
 721         (struct usb_descriptor_header *) &z_1,
 722         (struct usb_descriptor_header *) &z_2,
 723         (struct usb_descriptor_header *) &z_audio_if_desc,
 724         (struct usb_descriptor_header *) &z_audio_if_desc2,
 725         (struct usb_descriptor_header *) &z_audio_cs_as_if_desc,
 726         (struct usb_descriptor_header *) &z_audio_cs_as_format_desc,
 727         (struct usb_descriptor_header *) &z_iso_ep,
 728         (struct usb_descriptor_header *) &z_iso_ep2,
 729         (struct usb_descriptor_header *) &za_0,
 730         (struct usb_descriptor_header *) &za_1,
 731         (struct usb_descriptor_header *) &za_2,
 732         (struct usb_descriptor_header *) &za_3,
 733         (struct usb_descriptor_header *) &za_4,
 734         (struct usb_descriptor_header *) &za_5,
 735         (struct usb_descriptor_header *) &za_6,
 736         (struct usb_descriptor_header *) &za_7,
 737         (struct usb_descriptor_header *) &za_8,
 738         (struct usb_descriptor_header *) &za_9,
 739         (struct usb_descriptor_header *) &za_10,
 740         (struct usb_descriptor_header *) &za_11,
 741         (struct usb_descriptor_header *) &za_12,
 742         (struct usb_descriptor_header *) &za_13,
 743         (struct usb_descriptor_header *) &za_14,
 744         (struct usb_descriptor_header *) &za_15,
 745         (struct usb_descriptor_header *) &za_16,
 746         (struct usb_descriptor_header *) &za_17,
 747         (struct usb_descriptor_header *) &za_18,
 748         (struct usb_descriptor_header *) &za_19,
 749         (struct usb_descriptor_header *) &za_20,
 750         (struct usb_descriptor_header *) &za_21,
 751         (struct usb_descriptor_header *) &za_22,
 752         (struct usb_descriptor_header *) &za_23,
 753         (struct usb_descriptor_header *) &za_24,
 754         NULL,
 755 };
 756
 757 /* maxpacket and other transfer characteristics vary by speed. */
 758 #define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
 759
 760 #else
 761
 762 /* if there's no high speed support, maxpacket doesn't change. */
 763 #define ep_desc(g,hs,fs) fs
 764
 765 #endif  /* !CONFIG_USB_GADGET_DUALSPEED */
 766
 767 static char                             manufacturer [40];
 768 //static char                           serial [40];
 769 static char                             serial [] = "Ser 00 em";
 770
 771 /* static strings, in UTF-8 */
 772 static struct usb_string                strings [] = {
 773         { STRING_MANUFACTURER, manufacturer, },
 774         { STRING_PRODUCT, longname, },
 775         { STRING_SERIAL, serial, },
 776         { STRING_LOOPBACK, loopback, },
 777         { STRING_SOURCE_SINK, source_sink, },
 778         {  }                    /* end of list */
 779 };
 780
 781 static struct usb_gadget_strings        stringtab = {
 782         .language       = 0x0409,       /* en-us */
 783         .strings        = strings,
 784 };
 785
 786 /*
 787  * config descriptors are also handcrafted.  these must agree with code
 788  * that sets configurations, and with code managing interfaces and their
 789  * altsettings.  other complexity may come from:
 790  *
 791  *  - high speed support, including "other speed config" rules
 792  *  - multiple configurations
 793  *  - interfaces with alternate settings
 794  *  - embedded class or vendor-specific descriptors
 795  *
 796  * this handles high speed, and has a second config that could as easily
 797  * have been an alternate interface setting (on most hardware).
 798  *
 799  * NOTE:  to demonstrate (and test) more USB capabilities, this driver
 800  * should include an altsetting to test interrupt transfers, including
 801  * high bandwidth modes at high speed.  (Maybe work like Intel's test
 802  * device?)
 803  */
 804 static int
 805 config_buf (struct usb_gadget *gadget, u8 *buf, u8 type, unsigned index)
 806 {
 807         int len;
 808         const struct usb_descriptor_header **function;
 809
 810         function = z_function;
 811         len = usb_gadget_config_buf (&z_config, buf, USB_BUFSIZ, function);
 812         if (len < 0)
 813                 return len;
 814         ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
 815         return len;
 816 }
 817
 818 /*-------------------------------------------------------------------------*/
 819
 820 static struct usb_request *
 821 alloc_ep_req (struct usb_ep *ep, unsigned length)
 822 {
 823         struct usb_request      *req;
 824
 825         req = usb_ep_alloc_request (ep, GFP_ATOMIC);
 826         if (req) {
 827                 req->length = length;
 828                 req->buf = usb_ep_alloc_buffer (ep, length,
 829                                 &req->dma, GFP_ATOMIC);
 830                 if (!req->buf) {
 831                         usb_ep_free_request (ep, req);
 832                         req = NULL;
 833                 }
 834         }
 835         return req;
 836 }
 837
 838 static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
 839 {
 840         if (req->buf)
 841                 usb_ep_free_buffer (ep, req->buf, req->dma, req->length);
 842         usb_ep_free_request (ep, req);
 843 }
 844
 845 /*-------------------------------------------------------------------------*/
 846
 847 /* optionally require specific source/sink data patterns  */
 848
 849 static int
 850 check_read_data (
 851         struct zero_dev         *dev,
 852         struct usb_ep           *ep,
 853         struct usb_request      *req
 854 )
 855 {
 856         unsigned        i;
 857         u8              *buf = req->buf;
 858
 859         for (i = 0; i < req->actual; i++, buf++) {
 860                 switch (pattern) {
 861                 /* all-zeroes has no synchronization issues */
 862                 case 0:
 863                         if (*buf == 0)
 864                                 continue;
 865                         break;
 866                 /* mod63 stays in sync with short-terminated transfers,
 867                  * or otherwise when host and gadget agree on how large
 868                  * each usb transfer request should be.  resync is done
 869                  * with set_interface or set_config.
 870                  */
 871                 case 1:
 872                         if (*buf == (u8)(i % 63))
 873                                 continue;
 874                         break;
 875                 }
 876                 ERROR (dev, "bad OUT byte, buf [%d] = %d\n", i, *buf);
 877                 usb_ep_set_halt (ep);
 878                 return -EINVAL;
 879         }
 880         return 0;
 881 }
 882
 883 /*-------------------------------------------------------------------------*/
 884
 885 static void zero_reset_config (struct zero_dev *dev)
 886 {
 887         if (dev->config == 0)
 888                 return;
 889
 890         DBG (dev, "reset config\n");
 891
 892         /* just disable endpoints, forcing completion of pending i/o.
 893          * all our completion handlers free their requests in this case.
 894          */
 895         if (dev->in_ep) {
 896                 usb_ep_disable (dev->in_ep);
 897                 dev->in_ep = NULL;
 898         }
 899         if (dev->out_ep) {
 900                 usb_ep_disable (dev->out_ep);
 901                 dev->out_ep = NULL;
 902         }
 903         dev->config = 0;
 904         del_timer (&dev->resume);
 905 }
 906
 907 #define _write(f, buf, sz) (f->f_op->write(f, buf, sz, &f->f_pos))
 908
 909 static void
 910 zero_isoc_complete (struct usb_ep *ep, struct usb_request *req)
 911 {
 912         struct zero_dev *dev = ep->driver_data;
 913         int             status = req->status;
 914         int i, j;
 915
 916         switch (status) {
 917
 918         case 0:                         /* normal completion? */
 919                 //printk ("\nzero ---------------> isoc normal completion %d bytes\n", req->actual);
 920                 for (i=0, j=rbuf_start; i<req->actual; i++) {
 921                         //printk ("%02x ", ((__u8*)req->buf)[i]);
 922                         rbuf[j] = ((__u8*)req->buf)[i];
 923                         j++;
 924                         if (j >= RBUF_LEN) j=0;
 925                 }
 926                 rbuf_start = j;
 927                 //printk ("\n\n");
 928
 929                 if (rbuf_len < RBUF_LEN) {
 930                         rbuf_len += req->actual;
 931                         if (rbuf_len > RBUF_LEN) {
 932                                 rbuf_len = RBUF_LEN;
 933                         }
 934                 }
 935
 936                 break;
 937
 938         /* this endpoint is normally active while we're configured */
 939         case -ECONNABORTED:             /* hardware forced ep reset */
 940         case -ECONNRESET:               /* request dequeued */
 941         case -ESHUTDOWN:                /* disconnect from host */
 942                 VDBG (dev, "%s gone (%d), %d/%d\n", ep->name, status,
 943                                 req->actual, req->length);
 944                 if (ep == dev->out_ep)
 945                         check_read_data (dev, ep, req);
 946                 free_ep_req (ep, req);
 947                 return;
 948
 949         case -EOVERFLOW:                /* buffer overrun on read means that
 950                                          * we didn't provide a big enough
 951                                          * buffer.
 952                                          */
 953         default:
 954 #if 1
 955                 DBG (dev, "%s complete --> %d, %d/%d\n", ep->name,
 956                                 status, req->actual, req->length);
 957 #endif
 958         case -EREMOTEIO:                /* short read */
 959                 break;
 960         }
 961
 962         status = usb_ep_queue (ep, req, GFP_ATOMIC);
 963         if (status) {
 964                 ERROR (dev, "kill %s:  resubmit %d bytes --> %d\n",
 965                                 ep->name, req->length, status);
 966                 usb_ep_set_halt (ep);
 967                 /* FIXME recover later ... somehow */
 968         }
 969 }
 970
 971 static struct usb_request *
 972 zero_start_isoc_ep (struct usb_ep *ep, int gfp_flags)
 973 {
 974         struct usb_request      *req;
 975         int                     status;
 976
 977         req = alloc_ep_req (ep, 512);
 978         if (!req)
 979                 return NULL;
 980
 981         req->complete = zero_isoc_complete;
 982
 983         status = usb_ep_queue (ep, req, gfp_flags);
 984         if (status) {
 985                 struct zero_dev *dev = ep->driver_data;
 986
 987                 ERROR (dev, "start %s --> %d\n", ep->name, status);
 988                 free_ep_req (ep, req);
 989                 req = NULL;
 990         }
 991
 992         return req;
 993 }
 994
 995 /* change our operational config.  this code must agree with the code
 996  * that returns config descriptors, and altsetting code.
 997  *
 998  * it's also responsible for power management interactions. some
 999  * configurations might not work with our current power sources.
1000  *
1001  * note that some device controller hardware will constrain what this
1002  * code can do, perhaps by disallowing more than one configuration or
1003  * by limiting configuration choices (like the pxa2xx).
1004  */
1005 static int
1006 zero_set_config (struct zero_dev *dev, unsigned number, int gfp_flags)
1007 {
1008         int                     result = 0;
1009         struct usb_gadget       *gadget = dev->gadget;
1010         const struct usb_endpoint_descriptor    *d;
1011         struct usb_ep           *ep;
1012
1013         if (number == dev->config)
1014                 return 0;
1015
1016         zero_reset_config (dev);
1017
1018         gadget_for_each_ep (ep, gadget) {
1019
1020                 if (strcmp (ep->name, "ep4") == 0) {
1021
1022                         d = (struct usb_endpoint_descripter *)&za_23; // isoc ep desc for audio i/f alt setting 6
1023                         result = usb_ep_enable (ep, d);
1024
1025                         if (result == 0) {
1026                                 ep->driver_data = dev;
1027                                 dev->in_ep = ep;
1028
1029                                 if (zero_start_isoc_ep (ep, gfp_flags) != 0) {
1030
1031                                         dev->in_ep = ep;
1032                                         continue;
1033                                 }
1034
1035                                 usb_ep_disable (ep);
1036                                 result = -EIO;
1037                         }
1038                 }
1039
1040         }
1041
1042         dev->config = number;
1043         return result;
1044 }
1045
1046 /*-------------------------------------------------------------------------*/
1047
1048 static void zero_setup_complete (struct usb_ep *ep, struct usb_request *req)
1049 {
1050         if (req->status || req->actual != req->length)
1051                 DBG ((struct zero_dev *) ep->driver_data,
1052                                 "setup complete --> %d, %d/%d\n",
1053                                 req->status, req->actual, req->length);
1054 }
1055
1056 /*
1057  * The setup() callback implements all the ep0 functionality that's
1058  * not handled lower down, in hardware or the hardware driver (like
1059  * device and endpoint feature flags, and their status).  It's all
1060  * housekeeping for the gadget function we're implementing.  Most of
1061  * the work is in config-specific setup.
1062  */
1063 static int
1064 zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1065 {
1066         struct zero_dev         *dev = get_gadget_data (gadget);
1067         struct usb_request      *req = dev->req;
1068         int                     value = -EOPNOTSUPP;
1069
1070         /* usually this stores reply data in the pre-allocated ep0 buffer,
1071          * but config change events will reconfigure hardware.
1072          */
1073         req->zero = 0;
1074         switch (ctrl->bRequest) {
1075
1076         case USB_REQ_GET_DESCRIPTOR:
1077
1078                 switch (ctrl->wValue >> 8) {
1079
1080                 case USB_DT_DEVICE:
1081                         value = min (ctrl->wLength, (u16) sizeof device_desc);
1082                         memcpy (req->buf, &device_desc, value);
1083                         break;
1084 #ifdef CONFIG_USB_GADGET_DUALSPEED
1085                 case USB_DT_DEVICE_QUALIFIER:
1086                         if (!gadget->is_dualspeed)
1087                                 break;
1088                         value = min (ctrl->wLength, (u16) sizeof dev_qualifier);
1089                         memcpy (req->buf, &dev_qualifier, value);
1090                         break;
1091
1092                 case USB_DT_OTHER_SPEED_CONFIG:
1093                         if (!gadget->is_dualspeed)
1094                                 break;
1095                         // FALLTHROUGH
1096 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1097                 case USB_DT_CONFIG:
1098                         value = config_buf (gadget, req->buf,
1099                                         ctrl->wValue >> 8,
1100                                         ctrl->wValue & 0xff);
1101                         if (value >= 0)
1102                                 value = min (ctrl->wLength, (u16) value);
1103                         break;
1104
1105                 case USB_DT_STRING:
1106                         /* wIndex == language code.
1107                          * this driver only handles one language, you can
1108                          * add string tables for other languages, using
1109                          * any UTF-8 characters
1110                          */
1111                         value = usb_gadget_get_string (&stringtab,
1112                                         ctrl->wValue & 0xff, req->buf);
1113                         if (value >= 0) {
1114                                 value = min (ctrl->wLength, (u16) value);
1115                         }
1116                         break;
1117                 }
1118                 break;
1119
1120         /* currently two configs, two speeds */
1121         case USB_REQ_SET_CONFIGURATION:
1122                 if (ctrl->bRequestType != 0)
1123                         goto unknown;
1124
1125                 spin_lock (&dev->lock);
1126                 value = zero_set_config (dev, ctrl->wValue, GFP_ATOMIC);
1127                 spin_unlock (&dev->lock);
1128                 break;
1129         case USB_REQ_GET_CONFIGURATION:
1130                 if (ctrl->bRequestType != USB_DIR_IN)
1131                         goto unknown;
1132                 *(u8 *)req->buf = dev->config;
1133                 value = min (ctrl->wLength, (u16) 1);
1134                 break;
1135
1136         /* until we add altsetting support, or other interfaces,
1137          * only 0/0 are possible.  pxa2xx only supports 0/0 (poorly)
1138          * and already killed pending endpoint I/O.
1139          */
1140         case USB_REQ_SET_INTERFACE:
1141
1142                 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1143                         goto unknown;
1144                 spin_lock (&dev->lock);
1145                 if (dev->config) {
1146                         u8              config = dev->config;
1147
1148                         /* resets interface configuration, forgets about
1149                          * previous transaction state (queued bufs, etc)
1150                          * and re-inits endpoint state (toggle etc)
1151                          * no response queued, just zero status == success.
1152                          * if we had more than one interface we couldn't
1153                          * use this "reset the config" shortcut.
1154                          */
1155                         zero_reset_config (dev);
1156                         zero_set_config (dev, config, GFP_ATOMIC);
1157                         value = 0;
1158                 }
1159                 spin_unlock (&dev->lock);
1160                 break;
1161         case USB_REQ_GET_INTERFACE:
1162                 if ((ctrl->bRequestType == 0x21) && (ctrl->wIndex == 0x02)) {
1163                         value = ctrl->wLength;
1164                         break;
1165                 }
1166                 else {
1167                         if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1168                                 goto unknown;
1169                         if (!dev->config)
1170                                 break;
1171                         if (ctrl->wIndex != 0) {
1172                                 value = -EDOM;
1173                                 break;
1174                         }
1175                         *(u8 *)req->buf = 0;
1176                         value = min (ctrl->wLength, (u16) 1);
1177                 }
1178                 break;
1179
1180         /*
1181          * These are the same vendor-specific requests supported by
1182          * Intel's USB 2.0 compliance test devices.  We exceed that
1183          * device spec by allowing multiple-packet requests.
1184          */
1185         case 0x5b:      /* control WRITE test -- fill the buffer */
1186                 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
1187                         goto unknown;
1188                 if (ctrl->wValue || ctrl->wIndex)
1189                         break;
1190                 /* just read that many bytes into the buffer */
1191                 if (ctrl->wLength > USB_BUFSIZ)
1192                         break;
1193                 value = ctrl->wLength;
1194                 break;
1195         case 0x5c:      /* control READ test -- return the buffer */
1196                 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
1197                         goto unknown;
1198                 if (ctrl->wValue || ctrl->wIndex)
1199                         break;
1200                 /* expect those bytes are still in the buffer; send back */
1201                 if (ctrl->wLength > USB_BUFSIZ
1202                                 || ctrl->wLength != req->length)
1203                         break;
1204                 value = ctrl->wLength;
1205                 break;
1206
1207         case 0x01: // SET_CUR
1208         case 0x02:
1209         case 0x03:
1210         case 0x04:
1211         case 0x05:
1212                 value = ctrl->wLength;
1213                 break;
1214         case 0x81:
1215                 switch (ctrl->wValue) {
1216                 case 0x0201:
1217                 case 0x0202:
1218                         ((u8*)req->buf)[0] = 0x00;
1219                         ((u8*)req->buf)[1] = 0xe3;
1220                         break;
1221                 case 0x0300:
1222                 case 0x0500:
1223                         ((u8*)req->buf)[0] = 0x00;
1224                         break;
1225                 }
1226                 //((u8*)req->buf)[0] = 0x81;
1227                 //((u8*)req->buf)[1] = 0x81;
1228                 value = ctrl->wLength;
1229                 break;
1230         case 0x82:
1231                 switch (ctrl->wValue) {
1232                 case 0x0201:
1233                 case 0x0202:
1234                         ((u8*)req->buf)[0] = 0x00;
1235                         ((u8*)req->buf)[1] = 0xc3;
1236                         break;
1237                 case 0x0300:
1238                 case 0x0500:
1239                         ((u8*)req->buf)[0] = 0x00;
1240                         break;
1241                 }
1242                 //((u8*)req->buf)[0] = 0x82;
1243                 //((u8*)req->buf)[1] = 0x82;
1244                 value = ctrl->wLength;
1245                 break;
1246         case 0x83:
1247                 switch (ctrl->wValue) {
1248                 case 0x0201:
1249                 case 0x0202:
1250                         ((u8*)req->buf)[0] = 0x00;
1251                         ((u8*)req->buf)[1] = 0x00;
1252                         break;
1253                 case 0x0300:
1254                         ((u8*)req->buf)[0] = 0x60;
1255                         break;
1256                 case 0x0500:
1257                         ((u8*)req->buf)[0] = 0x18;
1258                         break;
1259                 }
1260                 //((u8*)req->buf)[0] = 0x83;
1261                 //((u8*)req->buf)[1] = 0x83;
1262                 value = ctrl->wLength;
1263                 break;
1264         case 0x84:
1265                 switch (ctrl->wValue) {
1266                 case 0x0201:
1267                 case 0x0202:
1268                         ((u8*)req->buf)[0] = 0x00;
1269                         ((u8*)req->buf)[1] = 0x01;
1270                         break;
1271                 case 0x0300:
1272                 case 0x0500:
1273                         ((u8*)req->buf)[0] = 0x08;
1274                         break;
1275                 }
1276                 //((u8*)req->buf)[0] = 0x84;
1277                 //((u8*)req->buf)[1] = 0x84;
1278                 value = ctrl->wLength;
1279                 break;
1280         case 0x85:
1281                 ((u8*)req->buf)[0] = 0x85;
1282                 ((u8*)req->buf)[1] = 0x85;
1283                 value = ctrl->wLength;
1284                 break;
1285
1286
1287         default:
1288 unknown:
1289                 printk("unknown control req%02x.%02x v%04x i%04x l%d\n",
1290                         ctrl->bRequestType, ctrl->bRequest,
1291                         ctrl->wValue, ctrl->wIndex, ctrl->wLength);
1292         }
1293
1294         /* respond with data transfer before status phase? */
1295         if (value >= 0) {
1296                 req->length = value;
1297                 req->zero = value < ctrl->wLength
1298                                 && (value % gadget->ep0->maxpacket) == 0;
1299                 value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
1300                 if (value < 0) {
1301                         DBG (dev, "ep_queue < 0 --> %d\n", value);
1302                         req->status = 0;
1303                         zero_setup_complete (gadget->ep0, req);
1304                 }
1305         }
1306
1307         /* device either stalls (value < 0) or reports success */
1308         return value;
1309 }
1310
1311 static void
1312 zero_disconnect (struct usb_gadget *gadget)
1313 {
1314         struct zero_dev         *dev = get_gadget_data (gadget);
1315         unsigned long           flags;
1316
1317         spin_lock_irqsave (&dev->lock, flags);
1318         zero_reset_config (dev);
1319
1320         /* a more significant application might have some non-usb
1321          * activities to quiesce here, saving resources like power
1322          * or pushing the notification up a network stack.
1323          */
1324         spin_unlock_irqrestore (&dev->lock, flags);
1325
1326         /* next we may get setup() calls to enumerate new connections;
1327          * or an unbind() during shutdown (including removing module).
1328          */
1329 }
1330
1331 static void
1332 zero_autoresume (unsigned long _dev)
1333 {
1334         struct zero_dev *dev = (struct zero_dev *) _dev;
1335         int             status;
1336
1337         /* normally the host would be woken up for something
1338          * more significant than just a timer firing...
1339          */
1340         if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
1341                 status = usb_gadget_wakeup (dev->gadget);
1342                 DBG (dev, "wakeup --> %d\n", status);
1343         }
1344 }
1345
1346 /*-------------------------------------------------------------------------*/
1347
1348 static void
1349 zero_unbind (struct usb_gadget *gadget)
1350 {
1351         struct zero_dev         *dev = get_gadget_data (gadget);
1352
1353         DBG (dev, "unbind\n");
1354
1355         /* we've already been disconnected ... no i/o is active */
1356         if (dev->req)
1357                 free_ep_req (gadget->ep0, dev->req);
1358         del_timer_sync (&dev->resume);
1359         kfree (dev);
1360         set_gadget_data (gadget, NULL);
1361 }
1362
1363 static int
1364 zero_bind (struct usb_gadget *gadget)
1365 {
1366         struct zero_dev         *dev;
1367         //struct usb_ep         *ep;
1368
1369         printk("binding\n");
1370         /*
1371          * DRIVER POLICY CHOICE:  you may want to do this differently.
1372          * One thing to avoid is reusing a bcdDevice revision code
1373          * with different host-visible configurations or behavior
1374          * restrictions -- using ep1in/ep2out vs ep1out/ep3in, etc
1375          */
1376         //device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);
1377
1378
1379         /* ok, we made sense of the hardware ... */
1380         dev = kmalloc (sizeof *dev, SLAB_KERNEL);
1381         if (!dev)
1382                 return -ENOMEM;
1383         memset (dev, 0, sizeof *dev);
1384         spin_lock_init (&dev->lock);
1385         dev->gadget = gadget;
1386         set_gadget_data (gadget, dev);
1387
1388         /* preallocate control response and buffer */
1389         dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
1390         if (!dev->req)
1391                 goto enomem;
1392         dev->req->buf = usb_ep_alloc_buffer (gadget->ep0, USB_BUFSIZ,
1393                                 &dev->req->dma, GFP_KERNEL);
1394         if (!dev->req->buf)
1395                 goto enomem;
1396
1397         dev->req->complete = zero_setup_complete;
1398
1399         device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1400
1401 #ifdef CONFIG_USB_GADGET_DUALSPEED
1402         /* assume ep0 uses the same value for both speeds ... */
1403         dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
1404
1405         /* and that all endpoints are dual-speed */
1406         //hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
1407         //hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
1408 #endif
1409
1410         usb_gadget_set_selfpowered (gadget);
1411
1412         init_timer (&dev->resume);
1413         dev->resume.function = zero_autoresume;
1414         dev->resume.data = (unsigned long) dev;
1415
1416         gadget->ep0->driver_data = dev;
1417
1418         INFO (dev, "%s, version: " DRIVER_VERSION "\n", longname);
1419         INFO (dev, "using %s, OUT %s IN %s\n", gadget->name,
1420                 EP_OUT_NAME, EP_IN_NAME);
1421
1422         snprintf (manufacturer, sizeof manufacturer,
1423                 UTS_SYSNAME " " UTS_RELEASE " with %s",
1424                 gadget->name);
1425
1426         return 0;
1427
1428 enomem:
1429         zero_unbind (gadget);
1430         return -ENOMEM;
1431 }
1432
1433 /*-------------------------------------------------------------------------*/
1434
1435 static void
1436 zero_suspend (struct usb_gadget *gadget)
1437 {
1438         struct zero_dev         *dev = get_gadget_data (gadget);
1439
1440         if (gadget->speed == USB_SPEED_UNKNOWN)
1441                 return;
1442
1443         if (autoresume) {
1444                 mod_timer (&dev->resume, jiffies + (HZ * autoresume));
1445                 DBG (dev, "suspend, wakeup in %d seconds\n", autoresume);
1446         } else
1447                 DBG (dev, "suspend\n");
1448 }
1449
1450 static void
1451 zero_resume (struct usb_gadget *gadget)
1452 {
1453         struct zero_dev         *dev = get_gadget_data (gadget);
1454
1455         DBG (dev, "resume\n");
1456         del_timer (&dev->resume);
1457 }
1458
1459
1460 /*-------------------------------------------------------------------------*/
1461
1462 static struct usb_gadget_driver zero_driver = {
1463 #ifdef CONFIG_USB_GADGET_DUALSPEED
1464         .speed          = USB_SPEED_HIGH,
1465 #else
1466         .speed          = USB_SPEED_FULL,
1467 #endif
1468         .function       = (char *) longname,
1469         .bind           = zero_bind,
1470         .unbind         = zero_unbind,
1471
1472         .setup          = zero_setup,
1473         .disconnect     = zero_disconnect,
1474
1475         .suspend        = zero_suspend,
1476         .resume         = zero_resume,
1477
1478         .driver         = {
1479                 .name           = (char *) shortname,
1480                 // .shutdown = ...
1481                 // .suspend = ...
1482                 // .resume = ...
1483         },
1484 };
1485
1486 MODULE_AUTHOR ("David Brownell");
1487 MODULE_LICENSE ("Dual BSD/GPL");
1488
1489 static struct proc_dir_entry *pdir, *pfile;
1490
1491 static int isoc_read_data (char *page, char **start,
1492                            off_t off, int count,
1493                            int *eof, void *data)
1494 {
1495         int i;
1496         static int c = 0;
1497         static int done = 0;
1498         static int s = 0;
1499
1500 /*
1501         printk ("\ncount: %d\n", count);
1502         printk ("rbuf_start: %d\n", rbuf_start);
1503         printk ("rbuf_len: %d\n", rbuf_len);
1504         printk ("off: %d\n", off);
1505         printk ("start: %p\n\n", *start);
1506 */
1507         if (done) {
1508                 c = 0;
1509                 done = 0;
1510                 *eof = 1;
1511                 return 0;
1512         }
1513
1514         if (c == 0) {
1515                 if (rbuf_len == RBUF_LEN)
1516                         s = rbuf_start;
1517                 else s = 0;
1518         }
1519
1520         for (i=0; i<count && c<rbuf_len; i++, c++) {
1521                 page[i] = rbuf[(c+s) % RBUF_LEN];
1522         }
1523         *start = page;
1524
1525         if (c >= rbuf_len) {
1526                 *eof = 1;
1527                 done = 1;
1528         }
1529
1530
1531         return i;
1532 }
1533
1534 static int __init init (void)
1535 {
1536
1537         int retval = 0;
1538
1539         pdir = proc_mkdir("isoc_test", NULL);
1540         if(pdir == NULL) {
1541                 retval = -ENOMEM;
1542                 printk("Error creating dir\n");
1543                 goto done;
1544         }
1545         pdir->owner = THIS_MODULE;
1546
1547         pfile = create_proc_read_entry("isoc_data",
1548                                        0444, pdir,
1549                                        isoc_read_data,
1550                                        NULL);
1551         if (pfile == NULL) {
1552                 retval = -ENOMEM;
1553                 printk("Error creating file\n");
1554                 goto no_file;
1555         }
1556         pfile->owner = THIS_MODULE;
1557
1558         return usb_gadget_register_driver (&zero_driver);
1559
1560  no_file:
1561         remove_proc_entry("isoc_data", NULL);
1562  done:
1563         return retval;
1564 }
1565 module_init (init);
1566
1567 static void __exit cleanup (void)
1568 {
1569
1570         usb_gadget_unregister_driver (&zero_driver);
1571
1572         remove_proc_entry("isoc_data", pdir);
1573         remove_proc_entry("isoc_test", NULL);
1574 }
1575 module_exit (cleanup);