root/src/linux/rt2880/linux-2.6.23/drivers/usb/dwc_otg/dummy_audio.c

/*
 * zero.c -- Gadget Zero, for USB development
 *
 * Copyright (C) 2003-2004 David Brownell
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The names of the above-listed copyright holders may not be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * ALTERNATIVELY, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") as published by the Free Software
 * Foundation, either version 2 of that License or (at your option) any
 * later version.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


/*
 * Gadget Zero only needs two bulk endpoints, and is an example of how you
 * can write a hardware-agnostic gadget driver running inside a USB device.
 *
 * Hardware details are visible (see CONFIG_USB_ZERO_* below) but don't
 * affect most of the driver.
 *
 * Use it with the Linux host/master side "usbtest" driver to get a basic
 * functional test of your device-side usb stack, or with "usb-skeleton".
 *
 * It supports two similar configurations.  One sinks whatever the usb host
 * writes, and in return sources zeroes.  The other loops whatever the host
 * writes back, so the host can read it.  Module options include:
 *
 *   buflen=N           default N=4096, buffer size used
 *   qlen=N             default N=32, how many buffers in the loopback queue
 *   loopdefault        default false, list loopback config first
 *
 * Many drivers will only have one configuration, letting them be much
 * simpler if they also don't support high speed operation (like this
 * driver does).
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/smp_lock.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include <linux/uts.h>
#include <linux/version.h>
#include <linux/device.h>
#include <linux/moduleparam.h>
#include <linux/proc_fs.h>

#include <asm/byteorder.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/system.h>
#include <asm/unaligned.h>

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
# include <linux/usb/ch9.h>
#else
# include <linux/usb_ch9.h>
#endif

#include <linux/usb_gadget.h>


/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/


static int utf8_to_utf16le(const char *s, u16 *cp, unsigned len)
{
        int     count = 0;
        u8      c;
        u16     uchar;

        /* this insists on correct encodings, though not minimal ones.
         * BUT it currently rejects legit 4-byte UTF-8 code points,
         * which need surrogate pairs.  (Unicode 3.1 can use them.)
         */
        while (len != 0 && (c = (u8) *s++) != 0) {
                if (unlikely(c & 0x80)) {
                        // 2-byte sequence:
                        // 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
                        if ((c & 0xe0) == 0xc0) {
                                uchar = (c & 0x1f) << 6;

                                c = (u8) *s++;
                                if ((c & 0xc0) != 0xc0)
                                        goto fail;
                                c &= 0x3f;
                                uchar |= c;

                        // 3-byte sequence (most CJKV characters):
                        // zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
                        } else if ((c & 0xf0) == 0xe0) {
                                uchar = (c & 0x0f) << 12;

                                c = (u8) *s++;
                                if ((c & 0xc0) != 0xc0)
                                        goto fail;
                                c &= 0x3f;
                                uchar |= c << 6;

                                c = (u8) *s++;
                                if ((c & 0xc0) != 0xc0)
                                        goto fail;
                                c &= 0x3f;
                                uchar |= c;

                                /* no bogus surrogates */
                                if (0xd800 <= uchar && uchar <= 0xdfff)
                                        goto fail;

                        // 4-byte sequence (surrogate pairs, currently rare):
                        // 11101110wwwwzzzzyy + 110111yyyyxxxxxx
                        //     = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
                        // (uuuuu = wwww + 1)
                        // FIXME accept the surrogate code points (only)

                        } else
                                goto fail;
                } else
                        uchar = c;
                put_unaligned (cpu_to_le16 (uchar), cp++);
                count++;
                len--;
        }
        return count;
fail:
        return -1;
}


/**
 * usb_gadget_get_string - fill out a string descriptor 
 * @table: of c strings encoded using UTF-8
 * @id: string id, from low byte of wValue in get string descriptor
 * @buf: at least 256 bytes
 *
 * Finds the UTF-8 string matching the ID, and converts it into a
 * string descriptor in utf16-le.
 * Returns length of descriptor (always even) or negative errno
 *
 * If your driver needs stings in multiple languages, you'll probably
 * "switch (wIndex) { ... }"  in your ep0 string descriptor logic,
 * using this routine after choosing which set of UTF-8 strings to use.
 * Note that US-ASCII is a strict subset of UTF-8; any string bytes with
 * the eighth bit set will be multibyte UTF-8 characters, not ISO-8859/1
 * characters (which are also widely used in C strings).
 */
int
usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
{
        struct usb_string       *s;
        int                     len;

        /* descriptor 0 has the language id */
        if (id == 0) {
                buf [0] = 4;
                buf [1] = USB_DT_STRING;
                buf [2] = (u8) table->language;
                buf [3] = (u8) (table->language >> 8);
                return 4;
        }
        for (s = table->strings; s && s->s; s++)
                if (s->id == id)
                        break;

        /* unrecognized: stall. */
        if (!s || !s->s)
                return -EINVAL;

        /* string descriptors have length, tag, then UTF16-LE text */
        len = min ((size_t) 126, strlen (s->s));
        memset (buf + 2, 0, 2 * len);   /* zero all the bytes */
        len = utf8_to_utf16le(s->s, (u16 *)&buf[2], len);
        if (len < 0)
                return -EINVAL;
        buf [0] = (len + 1) * 2;
        buf [1] = USB_DT_STRING;
        return buf [0];
}


/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/


/**
 * usb_descriptor_fillbuf - fill buffer with descriptors
 * @buf: Buffer to be filled
 * @buflen: Size of buf
 * @src: Array of descriptor pointers, terminated by null pointer.
 *
 * Copies descriptors into the buffer, returning the length or a
 * negative error code if they can't all be copied.  Useful when
 * assembling descriptors for an associated set of interfaces used
 * as part of configuring a composite device; or in other cases where
 * sets of descriptors need to be marshaled.
 */
int
usb_descriptor_fillbuf(void *buf, unsigned buflen,
                const struct usb_descriptor_header **src)
{
        u8      *dest = buf;

        if (!src)
                return -EINVAL;

        /* fill buffer from src[] until null descriptor ptr */
        for (; 0 != *src; src++) {
                unsigned                len = (*src)->bLength;

                if (len > buflen)
                        return -EINVAL;
                memcpy(dest, *src, len);
                buflen -= len;
                dest += len;
        }
        return dest - (u8 *)buf;
}


/**
 * usb_gadget_config_buf - builts a complete configuration descriptor
 * @config: Header for the descriptor, including characteristics such
 *      as power requirements and number of interfaces.
 * @desc: Null-terminated vector of pointers to the descriptors (interface,
 *      endpoint, etc) defining all functions in this device configuration.
 * @buf: Buffer for the resulting configuration descriptor.
 * @length: Length of buffer.  If this is not big enough to hold the
 *      entire configuration descriptor, an error code will be returned.
 *
 * This copies descriptors into the response buffer, building a descriptor
 * for that configuration.  It returns the buffer length or a negative
 * status code.  The config.wTotalLength field is set to match the length
 * of the result, but other descriptor fields (including power usage and
 * interface count) must be set by the caller.
 *
 * Gadget drivers could use this when constructing a config descriptor
 * in response to USB_REQ_GET_DESCRIPTOR.  They will need to patch the
 * resulting bDescriptorType value if USB_DT_OTHER_SPEED_CONFIG is needed.
 */
int usb_gadget_config_buf(
        const struct usb_config_descriptor      *config,
        void                                    *buf,
        unsigned                                length,
        const struct usb_descriptor_header      **desc
)
{
        struct usb_config_descriptor            *cp = buf;
        int                                     len;

        /* config descriptor first */
        if (length < USB_DT_CONFIG_SIZE || !desc)
                return -EINVAL;
        *cp = *config; 

        /* then interface/endpoint/class/vendor/... */
        len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf,
                        length - USB_DT_CONFIG_SIZE, desc);
        if (len < 0)
                return len;
        len += USB_DT_CONFIG_SIZE;
        if (len > 0xffff)
                return -EINVAL;

        /* patch up the config descriptor */
        cp->bLength = USB_DT_CONFIG_SIZE;
        cp->bDescriptorType = USB_DT_CONFIG;
        cp->wTotalLength = cpu_to_le16(len);
        cp->bmAttributes |= USB_CONFIG_ATT_ONE;
        return len;
}

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/


#define RBUF_LEN (1024*1024)
static int rbuf_start;
static int rbuf_len;
static __u8 rbuf[RBUF_LEN];

/*-------------------------------------------------------------------------*/

#define DRIVER_VERSION          "St Patrick's Day 2004"

static const char shortname [] = "zero";
static const char longname [] = "YAMAHA YST-MS35D USB Speaker  ";

static const char source_sink [] = "source and sink data";
static const char loopback [] = "loop input to output";

/*-------------------------------------------------------------------------*/

/*
 * driver assumes self-powered hardware, and
 * has no way for users to trigger remote wakeup.
 *
 * this version autoconfigures as much as possible,
 * which is reasonable for most "bulk-only" drivers.
 */
static const char *EP_IN_NAME;          /* source */
static const char *EP_OUT_NAME;         /* sink */

/*-------------------------------------------------------------------------*/

/* big enough to hold our biggest descriptor */
#define USB_BUFSIZ      512

struct zero_dev {
        spinlock_t              lock;
        struct usb_gadget       *gadget;
        struct usb_request      *req;           /* for control responses */

        /* when configured, we have one of two configs:
         * - source data (in to host) and sink it (out from host)
         * - or loop it back (out from host back in to host)
         */
        u8                      config;
        struct usb_ep           *in_ep, *out_ep;

        /* autoresume timer */
        struct timer_list       resume;
};

#define xprintk(d,level,fmt,args...) \
        dev_printk(level , &(d)->gadget->dev , fmt , ## args)

#ifdef DEBUG
#define DBG(dev,fmt,args...) \
        xprintk(dev , KERN_DEBUG , fmt , ## args)
#else
#define DBG(dev,fmt,args...) \
        do { } while (0)
#endif /* DEBUG */

#ifdef VERBOSE
#define VDBG    DBG
#else
#define VDBG(dev,fmt,args...) \
        do { } while (0)
#endif /* VERBOSE */

#define ERROR(dev,fmt,args...) \
        xprintk(dev , KERN_ERR , fmt , ## args)
#define WARN(dev,fmt,args...) \
        xprintk(dev , KERN_WARNING , fmt , ## args)
#define INFO(dev,fmt,args...) \
        xprintk(dev , KERN_INFO , fmt , ## args)

/*-------------------------------------------------------------------------*/

static unsigned buflen = 4096;
static unsigned qlen = 32;
static unsigned pattern = 0;

module_param (buflen, uint, S_IRUGO|S_IWUSR);
module_param (qlen, uint, S_IRUGO|S_IWUSR);
module_param (pattern, uint, S_IRUGO|S_IWUSR);

/*
 * if it's nonzero, autoresume says how many seconds to wait
 * before trying to wake up the host after suspend.
 */
static unsigned autoresume = 0;
module_param (autoresume, uint, 0);

/*
 * Normally the "loopback" configuration is second (index 1) so
 * it's not the default.  Here's where to change that order, to
 * work better with hosts where config changes are problematic.
 * Or controllers (like superh) that only support one config.
 */
static int loopdefault = 0;

module_param (loopdefault, bool, S_IRUGO|S_IWUSR);

/*-------------------------------------------------------------------------*/

/* Thanks to NetChip Technologies for donating this product ID.
 *
 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
 * Instead:  allocate your own, using normal USB-IF procedures.
 */
#ifndef CONFIG_USB_ZERO_HNPTEST
#define DRIVER_VENDOR_NUM       0x0525          /* NetChip */
#define DRIVER_PRODUCT_NUM      0xa4a0          /* Linux-USB "Gadget Zero" */
#else
#define DRIVER_VENDOR_NUM       0x1a0a          /* OTG test device IDs */
#define DRIVER_PRODUCT_NUM      0xbadd
#endif

/*-------------------------------------------------------------------------*/

/*
 * DESCRIPTORS ... most are static, but strings and (full)
 * configuration descriptors are built on demand.
 */

/*
#define STRING_MANUFACTURER             25
#define STRING_PRODUCT                  42
#define STRING_SERIAL                   101
*/
#define STRING_MANUFACTURER             1
#define STRING_PRODUCT                  2
#define STRING_SERIAL                   3

#define STRING_SOURCE_SINK              250
#define STRING_LOOPBACK                 251

/*
 * This device advertises two configurations; these numbers work
 * on a pxa250 as well as more flexible hardware.
 */
#define CONFIG_SOURCE_SINK      3
#define CONFIG_LOOPBACK         2

/*
static struct usb_device_descriptor
device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,

        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
        .bDeviceClass =         USB_CLASS_VENDOR_SPEC,

        .idVendor =             __constant_cpu_to_le16 (DRIVER_VENDOR_NUM),
        .idProduct =            __constant_cpu_to_le16 (DRIVER_PRODUCT_NUM),
        .iManufacturer =        STRING_MANUFACTURER,
        .iProduct =             STRING_PRODUCT,
        .iSerialNumber =        STRING_SERIAL,
        .bNumConfigurations =   2,
};
*/
static struct usb_device_descriptor
device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,
        .bcdUSB =               __constant_cpu_to_le16 (0x0100),
        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
        .bDeviceSubClass =      0,
        .bDeviceProtocol =      0,
        .bMaxPacketSize0 =      64,
        .bcdDevice =            __constant_cpu_to_le16 (0x0100),
        .idVendor =             __constant_cpu_to_le16 (0x0499),
        .idProduct =            __constant_cpu_to_le16 (0x3002),
        .iManufacturer =        STRING_MANUFACTURER,
        .iProduct =             STRING_PRODUCT,
        .iSerialNumber =        STRING_SERIAL,
        .bNumConfigurations =   1,
};

static struct usb_config_descriptor
z_config = {
        .bLength =              sizeof z_config,
        .bDescriptorType =      USB_DT_CONFIG,

        /* compute wTotalLength on the fly */
        .bNumInterfaces =       2,
        .bConfigurationValue =  1,
        .iConfiguration =       0,
        .bmAttributes =         0x40,
        .bMaxPower =            0,      /* self-powered */
};


static struct usb_otg_descriptor
otg_descriptor = {
        .bLength =              sizeof otg_descriptor,
        .bDescriptorType =      USB_DT_OTG,

        .bmAttributes =         USB_OTG_SRP,
};

/* one interface in each configuration */
#ifdef  CONFIG_USB_GADGET_DUALSPEED

/*
 * usb 2.0 devices need to expose both high speed and full speed
 * descriptors, unless they only run at full speed.
 *
 * that means alternate endpoint descriptors (bigger packets)
 * and a "device qualifier" ... plus more construction options
 * for the config descriptor.
 */

static struct usb_qualifier_descriptor
dev_qualifier = {
        .bLength =              sizeof dev_qualifier,
        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,

        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
        .bDeviceClass =         USB_CLASS_VENDOR_SPEC,

        .bNumConfigurations =   2,
};


struct usb_cs_as_general_descriptor {
        __u8  bLength;
        __u8  bDescriptorType;

        __u8  bDescriptorSubType;
        __u8  bTerminalLink;
        __u8  bDelay;
        __u16  wFormatTag;
} __attribute__ ((packed));

struct usb_cs_as_format_descriptor {
        __u8  bLength;
        __u8  bDescriptorType;

        __u8  bDescriptorSubType;
        __u8  bFormatType;
        __u8  bNrChannels;
        __u8  bSubframeSize;
        __u8  bBitResolution;
        __u8  bSamfreqType;
        __u8  tLowerSamFreq[3];
        __u8  tUpperSamFreq[3];
} __attribute__ ((packed));

static const struct usb_interface_descriptor
z_audio_control_if_desc = {
        .bLength =              sizeof z_audio_control_if_desc,
        .bDescriptorType =      USB_DT_INTERFACE,
        .bInterfaceNumber = 0,
        .bAlternateSetting = 0,
        .bNumEndpoints = 0,
        .bInterfaceClass = USB_CLASS_AUDIO,
        .bInterfaceSubClass = 0x1,
        .bInterfaceProtocol = 0,
        .iInterface = 0,
};

static const struct usb_interface_descriptor
z_audio_if_desc = {
        .bLength =              sizeof z_audio_if_desc,
        .bDescriptorType =      USB_DT_INTERFACE,
        .bInterfaceNumber = 1,
        .bAlternateSetting = 0,
        .bNumEndpoints = 0,
        .bInterfaceClass = USB_CLASS_AUDIO,
        .bInterfaceSubClass = 0x2,
        .bInterfaceProtocol = 0,
        .iInterface = 0,
};

static const struct usb_interface_descriptor
z_audio_if_desc2 = {
        .bLength =              sizeof z_audio_if_desc,
        .bDescriptorType =      USB_DT_INTERFACE,
        .bInterfaceNumber = 1,
        .bAlternateSetting = 1,
        .bNumEndpoints = 1,
        .bInterfaceClass = USB_CLASS_AUDIO,
        .bInterfaceSubClass = 0x2,
        .bInterfaceProtocol = 0,
        .iInterface = 0,
};

static const struct usb_cs_as_general_descriptor
z_audio_cs_as_if_desc = {
        .bLength = 7,
        .bDescriptorType = 0x24,
        
        .bDescriptorSubType = 0x01,
        .bTerminalLink = 0x01,
        .bDelay = 0x0,
        .wFormatTag = __constant_cpu_to_le16 (0x0001)
};


static const struct usb_cs_as_format_descriptor 
z_audio_cs_as_format_desc = {
        .bLength = 0xe,
        .bDescriptorType = 0x24,
        
        .bDescriptorSubType = 2,
        .bFormatType = 1,
        .bNrChannels = 1,
        .bSubframeSize = 1,
        .bBitResolution = 8,
        .bSamfreqType = 0,
        .tLowerSamFreq = {0x7e, 0x13, 0x00},
        .tUpperSamFreq = {0xe2, 0xd6, 0x00},
};

static const struct usb_endpoint_descriptor 
z_iso_ep = {
        .bLength = 0x09,
        .bDescriptorType = 0x05,
        .bEndpointAddress = 0x04,
        .bmAttributes = 0x09,
        .wMaxPacketSize = 0x0038,
        .bInterval = 0x01,
        .bRefresh = 0x00,
        .bSynchAddress = 0x00,  
};

static char z_iso_ep2[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};

// 9 bytes
static char z_ac_interface_header_desc[] = 
{ 0x09, 0x24, 0x01, 0x00, 0x01, 0x2b, 0x00, 0x01, 0x01 };

// 12 bytes
static char z_0[] = {0x0c, 0x24, 0x02, 0x01, 0x01, 0x01, 0x00, 0x02, 
                     0x03, 0x00, 0x00, 0x00};
// 13 bytes
static char z_1[] = {0x0d, 0x24, 0x06, 0x02, 0x01, 0x02, 0x15, 0x00, 
                     0x02, 0x00, 0x02, 0x00, 0x00};
// 9 bytes
static char z_2[] = {0x09, 0x24, 0x03, 0x03, 0x01, 0x03, 0x00, 0x02, 
                     0x00};

static char za_0[] = {0x09, 0x04, 0x01, 0x02, 0x01, 0x01, 0x02, 0x00, 
                      0x00};

static char za_1[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};

static char za_2[] = {0x0e, 0x24, 0x02, 0x01, 0x02, 0x01, 0x08, 0x00, 
                      0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};

static char za_3[] = {0x09, 0x05, 0x04, 0x09, 0x70, 0x00, 0x01, 0x00,
                      0x00};

static char za_4[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};

static char za_5[] = {0x09, 0x04, 0x01, 0x03, 0x01, 0x01, 0x02, 0x00,
                      0x00};

static char za_6[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};

static char za_7[] = {0x0e, 0x24, 0x02, 0x01, 0x01, 0x02, 0x10, 0x00,
                      0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};

static char za_8[] = {0x09, 0x05, 0x04, 0x09, 0x70, 0x00, 0x01, 0x00,
                      0x00};

static char za_9[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};

static char za_10[] = {0x09, 0x04, 0x01, 0x04, 0x01, 0x01, 0x02, 0x00,
                       0x00};

static char za_11[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};

static char za_12[] = {0x0e, 0x24, 0x02, 0x01, 0x02, 0x02, 0x10, 0x00,
                       0x73, 0x13, 0x00, 0xe2, 0xd6, 0x00};

static char za_13[] = {0x09, 0x05, 0x04, 0x09, 0xe0, 0x00, 0x01, 0x00,
                       0x00};

static char za_14[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};

static char za_15[] = {0x09, 0x04, 0x01, 0x05, 0x01, 0x01, 0x02, 0x00, 
                       0x00};

static char za_16[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};

static char za_17[] = {0x0e, 0x24, 0x02, 0x01, 0x01, 0x03, 0x14, 0x00, 
                       0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};

static char za_18[] = {0x09, 0x05, 0x04, 0x09, 0xa8, 0x00, 0x01, 0x00,
                       0x00};

static char za_19[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};

static char za_20[] = {0x09, 0x04, 0x01, 0x06, 0x01, 0x01, 0x02, 0x00,
                       0x00};

static char za_21[] = {0x07, 0x24, 0x01, 0x01, 0x00, 0x01, 0x00};

static char za_22[] = {0x0e, 0x24, 0x02, 0x01, 0x02, 0x03, 0x14, 0x00, 
                       0x7e, 0x13, 0x00, 0xe2, 0xd6, 0x00};

static char za_23[] = {0x09, 0x05, 0x04, 0x09, 0x50, 0x01, 0x01, 0x00,
                       0x00};

static char za_24[] = {0x07, 0x25, 0x01, 0x00, 0x02, 0x00, 0x02};



static const struct usb_descriptor_header *z_function [] = {
        (struct usb_descriptor_header *) &z_audio_control_if_desc,
        (struct usb_descriptor_header *) &z_ac_interface_header_desc,
        (struct usb_descriptor_header *) &z_0,
        (struct usb_descriptor_header *) &z_1,
        (struct usb_descriptor_header *) &z_2,
        (struct usb_descriptor_header *) &z_audio_if_desc,
        (struct usb_descriptor_header *) &z_audio_if_desc2,
        (struct usb_descriptor_header *) &z_audio_cs_as_if_desc,
        (struct usb_descriptor_header *) &z_audio_cs_as_format_desc,
        (struct usb_descriptor_header *) &z_iso_ep,
        (struct usb_descriptor_header *) &z_iso_ep2,
        (struct usb_descriptor_header *) &za_0,
        (struct usb_descriptor_header *) &za_1,
        (struct usb_descriptor_header *) &za_2,
        (struct usb_descriptor_header *) &za_3,
        (struct usb_descriptor_header *) &za_4,
        (struct usb_descriptor_header *) &za_5,
        (struct usb_descriptor_header *) &za_6,
        (struct usb_descriptor_header *) &za_7,
        (struct usb_descriptor_header *) &za_8,
        (struct usb_descriptor_header *) &za_9,
        (struct usb_descriptor_header *) &za_10,
        (struct usb_descriptor_header *) &za_11,
        (struct usb_descriptor_header *) &za_12,
        (struct usb_descriptor_header *) &za_13,
        (struct usb_descriptor_header *) &za_14,
        (struct usb_descriptor_header *) &za_15,
        (struct usb_descriptor_header *) &za_16,
        (struct usb_descriptor_header *) &za_17,
        (struct usb_descriptor_header *) &za_18,
        (struct usb_descriptor_header *) &za_19,
        (struct usb_descriptor_header *) &za_20,
        (struct usb_descriptor_header *) &za_21,
        (struct usb_descriptor_header *) &za_22,
        (struct usb_descriptor_header *) &za_23,
        (struct usb_descriptor_header *) &za_24,
        NULL,
};

/* maxpacket and other transfer characteristics vary by speed. */
#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))

#else

/* if there's no high speed support, maxpacket doesn't change. */
#define ep_desc(g,hs,fs) fs

#endif  /* !CONFIG_USB_GADGET_DUALSPEED */

static char                             manufacturer [40];
//static char                           serial [40];
static char                             serial [] = "Ser 00 em";

/* static strings, in UTF-8 */
static struct usb_string                strings [] = {
        { STRING_MANUFACTURER, manufacturer, },
        { STRING_PRODUCT, longname, },
        { STRING_SERIAL, serial, },
        { STRING_LOOPBACK, loopback, },
        { STRING_SOURCE_SINK, source_sink, },
        {  }                    /* end of list */
};

static struct usb_gadget_strings        stringtab = {
        .language       = 0x0409,       /* en-us */
        .strings        = strings,
};

/*
 * config descriptors are also handcrafted.  these must agree with code
 * that sets configurations, and with code managing interfaces and their
 * altsettings.  other complexity may come from:
 *
 *  - high speed support, including "other speed config" rules
 *  - multiple configurations
 *  - interfaces with alternate settings
 *  - embedded class or vendor-specific descriptors
 *
 * this handles high speed, and has a second config that could as easily
 * have been an alternate interface setting (on most hardware).
 *
 * NOTE:  to demonstrate (and test) more USB capabilities, this driver
 * should include an altsetting to test interrupt transfers, including
 * high bandwidth modes at high speed.  (Maybe work like Intel's test
 * device?)
 */
static int
config_buf (struct usb_gadget *gadget, u8 *buf, u8 type, unsigned index)
{
        int len;
        const struct usb_descriptor_header **function;
        
        function = z_function;
        len = usb_gadget_config_buf (&z_config, buf, USB_BUFSIZ, function);
        if (len < 0)
                return len;
        ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
        return len;
}

/*-------------------------------------------------------------------------*/

static struct usb_request *
alloc_ep_req (struct usb_ep *ep, unsigned length)
{
        struct usb_request      *req;

        req = usb_ep_alloc_request (ep, GFP_ATOMIC);
        if (req) {
                req->length = length;
                req->buf = usb_ep_alloc_buffer (ep, length,
                                &req->dma, GFP_ATOMIC);
                if (!req->buf) {
                        usb_ep_free_request (ep, req);
                        req = NULL;
                }
        }
        return req;
}

static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
{
        if (req->buf)
                usb_ep_free_buffer (ep, req->buf, req->dma, req->length);
        usb_ep_free_request (ep, req);
}

/*-------------------------------------------------------------------------*/

/* optionally require specific source/sink data patterns  */

static int
check_read_data (
        struct zero_dev         *dev,
        struct usb_ep           *ep,
        struct usb_request      *req
)
{
        unsigned        i;
        u8              *buf = req->buf;

        for (i = 0; i < req->actual; i++, buf++) {
                switch (pattern) {
                /* all-zeroes has no synchronization issues */
                case 0:
                        if (*buf == 0)
                                continue;
                        break;
                /* mod63 stays in sync with short-terminated transfers,
                 * or otherwise when host and gadget agree on how large
                 * each usb transfer request should be.  resync is done
                 * with set_interface or set_config.
                 */
                case 1:
                        if (*buf == (u8)(i % 63))
                                continue;
                        break;
                }
                ERROR (dev, "bad OUT byte, buf [%d] = %d\n", i, *buf);
                usb_ep_set_halt (ep);
                return -EINVAL;
        }
        return 0;
}

/*-------------------------------------------------------------------------*/

static void zero_reset_config (struct zero_dev *dev)
{
        if (dev->config == 0)
                return;

        DBG (dev, "reset config\n");

        /* just disable endpoints, forcing completion of pending i/o.
         * all our completion handlers free their requests in this case.
         */
        if (dev->in_ep) {
                usb_ep_disable (dev->in_ep);
                dev->in_ep = NULL;
        }
        if (dev->out_ep) {
                usb_ep_disable (dev->out_ep);
                dev->out_ep = NULL;
        }
        dev->config = 0;
        del_timer (&dev->resume);
}

#define _write(f, buf, sz) (f->f_op->write(f, buf, sz, &f->f_pos))

static void 
zero_isoc_complete (struct usb_ep *ep, struct usb_request *req)
{
        struct zero_dev *dev = ep->driver_data;
        int             status = req->status;
        int i, j;

        switch (status) {

        case 0:                         /* normal completion? */
                //printk ("\nzero ---------------> isoc normal completion %d bytes\n", req->actual);
                for (i=0, j=rbuf_start; i<req->actual; i++) {
                        //printk ("%02x ", ((__u8*)req->buf)[i]);
                        rbuf[j] = ((__u8*)req->buf)[i];
                        j++;
                        if (j >= RBUF_LEN) j=0;
                }
                rbuf_start = j;
                //printk ("\n\n");

                if (rbuf_len < RBUF_LEN) {
                        rbuf_len += req->actual;
                        if (rbuf_len > RBUF_LEN) {
                                rbuf_len = RBUF_LEN;
                        }
                }

                break;

        /* this endpoint is normally active while we're configured */
        case -ECONNABORTED:             /* hardware forced ep reset */
        case -ECONNRESET:               /* request dequeued */
        case -ESHUTDOWN:                /* disconnect from host */
                VDBG (dev, "%s gone (%d), %d/%d\n", ep->name, status,
                                req->actual, req->length);
                if (ep == dev->out_ep)
                        check_read_data (dev, ep, req);
                free_ep_req (ep, req);
                return;

        case -EOVERFLOW:                /* buffer overrun on read means that
                                         * we didn't provide a big enough
                                         * buffer.
                                         */
        default:
#if 1
                DBG (dev, "%s complete --> %d, %d/%d\n", ep->name,
                                status, req->actual, req->length);
#endif
        case -EREMOTEIO:                /* short read */
                break;
        }

        status = usb_ep_queue (ep, req, GFP_ATOMIC);
        if (status) {
                ERROR (dev, "kill %s:  resubmit %d bytes --> %d\n",
                                ep->name, req->length, status);
                usb_ep_set_halt (ep);
                /* FIXME recover later ... somehow */
        }
}

static struct usb_request *
zero_start_isoc_ep (struct usb_ep *ep, int gfp_flags)
{
        struct usb_request      *req;
        int                     status;

        req = alloc_ep_req (ep, 512);
        if (!req)
                return NULL;

        req->complete = zero_isoc_complete;

        status = usb_ep_queue (ep, req, gfp_flags);
        if (status) {
                struct zero_dev *dev = ep->driver_data;

                ERROR (dev, "start %s --> %d\n", ep->name, status);
                free_ep_req (ep, req);
                req = NULL;
        }

        return req;
}

/* change our operational config.  this code must agree with the code
 * that returns config descriptors, and altsetting code.
 *
 * it's also responsible for power management interactions. some
 * configurations might not work with our current power sources.
 *
 * note that some device controller hardware will constrain what this
 * code can do, perhaps by disallowing more than one configuration or
 * by limiting configuration choices (like the pxa2xx).
 */
static int
zero_set_config (struct zero_dev *dev, unsigned number, int gfp_flags)
{
        int                     result = 0;
        struct usb_gadget       *gadget = dev->gadget;
        const struct usb_endpoint_descriptor    *d;
        struct usb_ep           *ep;

        if (number == dev->config)
                return 0;

        zero_reset_config (dev);

        gadget_for_each_ep (ep, gadget) {

                if (strcmp (ep->name, "ep4") == 0) {

                        d = (struct usb_endpoint_descripter *)&za_23; // isoc ep desc for audio i/f alt setting 6
                        result = usb_ep_enable (ep, d);

                        if (result == 0) {
                                ep->driver_data = dev;
                                dev->in_ep = ep;

                                if (zero_start_isoc_ep (ep, gfp_flags) != 0) {

                                        dev->in_ep = ep;
                                        continue;
                                }

                                usb_ep_disable (ep);
                                result = -EIO;
                        }
                }

        }

        dev->config = number;
        return result;
}

/*-------------------------------------------------------------------------*/

static void zero_setup_complete (struct usb_ep *ep, struct usb_request *req)
{
        if (req->status || req->actual != req->length)
                DBG ((struct zero_dev *) ep->driver_data,
                                "setup complete --> %d, %d/%d\n",
                                req->status, req->actual, req->length);
}

/*
 * The setup() callback implements all the ep0 functionality that's
 * not handled lower down, in hardware or the hardware driver (like
 * device and endpoint feature flags, and their status).  It's all
 * housekeeping for the gadget function we're implementing.  Most of
 * the work is in config-specific setup.
 */
static int
zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
{
        struct zero_dev         *dev = get_gadget_data (gadget);
        struct usb_request      *req = dev->req;
        int                     value = -EOPNOTSUPP;

        /* usually this stores reply data in the pre-allocated ep0 buffer,
         * but config change events will reconfigure hardware.
         */
        req->zero = 0;
        switch (ctrl->bRequest) {

        case USB_REQ_GET_DESCRIPTOR:

                switch (ctrl->wValue >> 8) {

                case USB_DT_DEVICE:
                        value = min (ctrl->wLength, (u16) sizeof device_desc);
                        memcpy (req->buf, &device_desc, value);
                        break;
#ifdef CONFIG_USB_GADGET_DUALSPEED
                case USB_DT_DEVICE_QUALIFIER:
                        if (!gadget->is_dualspeed)
                                break;
                        value = min (ctrl->wLength, (u16) sizeof dev_qualifier);
                        memcpy (req->buf, &dev_qualifier, value);
                        break;

                case USB_DT_OTHER_SPEED_CONFIG:
                        if (!gadget->is_dualspeed)
                                break;
                        // FALLTHROUGH
#endif /* CONFIG_USB_GADGET_DUALSPEED */
                case USB_DT_CONFIG:
                        value = config_buf (gadget, req->buf,
                                        ctrl->wValue >> 8,
                                        ctrl->wValue & 0xff);
                        if (value >= 0)
                                value = min (ctrl->wLength, (u16) value);
                        break;

                case USB_DT_STRING:
                        /* wIndex == language code.
                         * this driver only handles one language, you can
                         * add string tables for other languages, using
                         * any UTF-8 characters
                         */
                        value = usb_gadget_get_string (&stringtab,
                                        ctrl->wValue & 0xff, req->buf);
                        if (value >= 0) {
                                value = min (ctrl->wLength, (u16) value);
                        }
                        break;
                }
                break;

        /* currently two configs, two speeds */
        case USB_REQ_SET_CONFIGURATION:
                if (ctrl->bRequestType != 0)
                        goto unknown;

                spin_lock (&dev->lock);
                value = zero_set_config (dev, ctrl->wValue, GFP_ATOMIC);
                spin_unlock (&dev->lock);
                break;
        case USB_REQ_GET_CONFIGURATION:
                if (ctrl->bRequestType != USB_DIR_IN)
                        goto unknown;
                *(u8 *)req->buf = dev->config;
                value = min (ctrl->wLength, (u16) 1);
                break;

        /* until we add altsetting support, or other interfaces,
         * only 0/0 are possible.  pxa2xx only supports 0/0 (poorly)
         * and already killed pending endpoint I/O.
         */
        case USB_REQ_SET_INTERFACE:

                if (ctrl->bRequestType != USB_RECIP_INTERFACE)
                        goto unknown;
                spin_lock (&dev->lock);
                if (dev->config) {
                        u8              config = dev->config;

                        /* resets interface configuration, forgets about
                         * previous transaction state (queued bufs, etc)
                         * and re-inits endpoint state (toggle etc)
                         * no response queued, just zero status == success.
                         * if we had more than one interface we couldn't
                         * use this "reset the config" shortcut.
                         */
                        zero_reset_config (dev);
                        zero_set_config (dev, config, GFP_ATOMIC);
                        value = 0;
                }
                spin_unlock (&dev->lock);
                break;
        case USB_REQ_GET_INTERFACE:
                if ((ctrl->bRequestType == 0x21) && (ctrl->wIndex == 0x02)) {
                        value = ctrl->wLength;
                        break;
                }
                else {
                        if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
                                goto unknown;
                        if (!dev->config)
                                break;
                        if (ctrl->wIndex != 0) {
                                value = -EDOM;
                                break;
                        }
                        *(u8 *)req->buf = 0;
                        value = min (ctrl->wLength, (u16) 1);
                }
                break;

        /*
         * These are the same vendor-specific requests supported by
         * Intel's USB 2.0 compliance test devices.  We exceed that
         * device spec by allowing multiple-packet requests.
         */
        case 0x5b:      /* control WRITE test -- fill the buffer */
                if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
                        goto unknown;
                if (ctrl->wValue || ctrl->wIndex)
                        break;
                /* just read that many bytes into the buffer */
                if (ctrl->wLength > USB_BUFSIZ)
                        break;
                value = ctrl->wLength;
                break;
        case 0x5c:      /* control READ test -- return the buffer */
                if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
                        goto unknown;
                if (ctrl->wValue || ctrl->wIndex)
                        break;
                /* expect those bytes are still in the buffer; send back */
                if (ctrl->wLength > USB_BUFSIZ
                                || ctrl->wLength != req->length)
                        break;
                value = ctrl->wLength;
                break;

        case 0x01: // SET_CUR
        case 0x02:
        case 0x03:
        case 0x04:
        case 0x05:
                value = ctrl->wLength;
                break;
        case 0x81:
                switch (ctrl->wValue) {
                case 0x0201:
                case 0x0202:
                        ((u8*)req->buf)[0] = 0x00;
                        ((u8*)req->buf)[1] = 0xe3;
                        break;
                case 0x0300:
                case 0x0500:
                        ((u8*)req->buf)[0] = 0x00;
                        break;
                }
                //((u8*)req->buf)[0] = 0x81;
                //((u8*)req->buf)[1] = 0x81;
                value = ctrl->wLength;
                break;
        case 0x82:
                switch (ctrl->wValue) {
                case 0x0201:
                case 0x0202:
                        ((u8*)req->buf)[0] = 0x00;
                        ((u8*)req->buf)[1] = 0xc3;
                        break;
                case 0x0300:
                case 0x0500:
                        ((u8*)req->buf)[0] = 0x00;
                        break;
                }
                //((u8*)req->buf)[0] = 0x82;
                //((u8*)req->buf)[1] = 0x82;
                value = ctrl->wLength;
                break;
        case 0x83:
                switch (ctrl->wValue) {
                case 0x0201:
                case 0x0202:
                        ((u8*)req->buf)[0] = 0x00;
                        ((u8*)req->buf)[1] = 0x00;
                        break;
                case 0x0300:
                        ((u8*)req->buf)[0] = 0x60;
                        break;
                case 0x0500:    
                        ((u8*)req->buf)[0] = 0x18;
                        break;
                }
                //((u8*)req->buf)[0] = 0x83;
                //((u8*)req->buf)[1] = 0x83;
                value = ctrl->wLength;
                break;
        case 0x84:
                switch (ctrl->wValue) {
                case 0x0201:
                case 0x0202:
                        ((u8*)req->buf)[0] = 0x00;
                        ((u8*)req->buf)[1] = 0x01;
                        break;
                case 0x0300:
                case 0x0500:
                        ((u8*)req->buf)[0] = 0x08;
                        break;
                }
                //((u8*)req->buf)[0] = 0x84;
                //((u8*)req->buf)[1] = 0x84;
                value = ctrl->wLength;
                break;
        case 0x85:
                ((u8*)req->buf)[0] = 0x85;
                ((u8*)req->buf)[1] = 0x85;
                value = ctrl->wLength;
                break;

        
        default:
unknown:
                printk("unknown control req%02x.%02x v%04x i%04x l%d\n",
                        ctrl->bRequestType, ctrl->bRequest,
                        ctrl->wValue, ctrl->wIndex, ctrl->wLength);
        }

        /* respond with data transfer before status phase? */
        if (value >= 0) {
                req->length = value;
                req->zero = value < ctrl->wLength
                                && (value % gadget->ep0->maxpacket) == 0;
                value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
                if (value < 0) {
                        DBG (dev, "ep_queue < 0 --> %d\n", value);
                        req->status = 0;
                        zero_setup_complete (gadget->ep0, req);
                }
        }

        /* device either stalls (value < 0) or reports success */
        return value;
}

static void
zero_disconnect (struct usb_gadget *gadget)
{
        struct zero_dev         *dev = get_gadget_data (gadget);
        unsigned long           flags;

        spin_lock_irqsave (&dev->lock, flags);
        zero_reset_config (dev);

        /* a more significant application might have some non-usb
         * activities to quiesce here, saving resources like power
         * or pushing the notification up a network stack.
         */
        spin_unlock_irqrestore (&dev->lock, flags);

        /* next we may get setup() calls to enumerate new connections;
         * or an unbind() during shutdown (including removing module).
         */
}

static void
zero_autoresume (unsigned long _dev)
{
        struct zero_dev *dev = (struct zero_dev *) _dev;
        int             status;

        /* normally the host would be woken up for something
         * more significant than just a timer firing...
         */
        if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
                status = usb_gadget_wakeup (dev->gadget);
                DBG (dev, "wakeup --> %d\n", status);
        }
}

/*-------------------------------------------------------------------------*/

static void
zero_unbind (struct usb_gadget *gadget)
{
        struct zero_dev         *dev = get_gadget_data (gadget);

        DBG (dev, "unbind\n");

        /* we've already been disconnected ... no i/o is active */
        if (dev->req)
                free_ep_req (gadget->ep0, dev->req);
        del_timer_sync (&dev->resume);
        kfree (dev);
        set_gadget_data (gadget, NULL);
}

static int
zero_bind (struct usb_gadget *gadget)
{
        struct zero_dev         *dev;
        //struct usb_ep         *ep;

        printk("binding\n");
        /*
         * DRIVER POLICY CHOICE:  you may want to do this differently.
         * One thing to avoid is reusing a bcdDevice revision code
         * with different host-visible configurations or behavior
         * restrictions -- using ep1in/ep2out vs ep1out/ep3in, etc
         */
        //device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);


        /* ok, we made sense of the hardware ... */
        dev = kmalloc (sizeof *dev, SLAB_KERNEL);
        if (!dev)
                return -ENOMEM;
        memset (dev, 0, sizeof *dev);
        spin_lock_init (&dev->lock);
        dev->gadget = gadget;
        set_gadget_data (gadget, dev);

        /* preallocate control response and buffer */
        dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
        if (!dev->req)
                goto enomem;
        dev->req->buf = usb_ep_alloc_buffer (gadget->ep0, USB_BUFSIZ,
                                &dev->req->dma, GFP_KERNEL);
        if (!dev->req->buf)
                goto enomem;

        dev->req->complete = zero_setup_complete;

        device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;

#ifdef CONFIG_USB_GADGET_DUALSPEED
        /* assume ep0 uses the same value for both speeds ... */
        dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;

        /* and that all endpoints are dual-speed */
        //hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
        //hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
#endif

        usb_gadget_set_selfpowered (gadget);

        init_timer (&dev->resume);
        dev->resume.function = zero_autoresume;
        dev->resume.data = (unsigned long) dev;

        gadget->ep0->driver_data = dev;

        INFO (dev, "%s, version: " DRIVER_VERSION "\n", longname);
        INFO (dev, "using %s, OUT %s IN %s\n", gadget->name,
                EP_OUT_NAME, EP_IN_NAME);

        snprintf (manufacturer, sizeof manufacturer,
                UTS_SYSNAME " " UTS_RELEASE " with %s",
                gadget->name);

        return 0;

enomem:
        zero_unbind (gadget);
        return -ENOMEM;
}

/*-------------------------------------------------------------------------*/

static void
zero_suspend (struct usb_gadget *gadget)
{
        struct zero_dev         *dev = get_gadget_data (gadget);

        if (gadget->speed == USB_SPEED_UNKNOWN)
                return;

        if (autoresume) {
                mod_timer (&dev->resume, jiffies + (HZ * autoresume));
                DBG (dev, "suspend, wakeup in %d seconds\n", autoresume);
        } else
                DBG (dev, "suspend\n");
}

static void
zero_resume (struct usb_gadget *gadget)
{
        struct zero_dev         *dev = get_gadget_data (gadget);

        DBG (dev, "resume\n");
        del_timer (&dev->resume);
}


/*-------------------------------------------------------------------------*/

static struct usb_gadget_driver zero_driver = {
#ifdef CONFIG_USB_GADGET_DUALSPEED
        .speed          = USB_SPEED_HIGH,
#else
        .speed          = USB_SPEED_FULL,
#endif
        .function       = (char *) longname,
        .bind           = zero_bind,
        .unbind         = zero_unbind,

        .setup          = zero_setup,
        .disconnect     = zero_disconnect,

        .suspend        = zero_suspend,
        .resume         = zero_resume,

        .driver         = {
                .name           = (char *) shortname,
                // .shutdown = ...
                // .suspend = ...
                // .resume = ...
        },
};

MODULE_AUTHOR ("David Brownell");
MODULE_LICENSE ("Dual BSD/GPL");

static struct proc_dir_entry *pdir, *pfile;

static int isoc_read_data (char *page, char **start,
                           off_t off, int count,
                           int *eof, void *data)
{
        int i;
        static int c = 0;
        static int done = 0;
        static int s = 0;

/*
        printk ("\ncount: %d\n", count);
        printk ("rbuf_start: %d\n", rbuf_start);
        printk ("rbuf_len: %d\n", rbuf_len);
        printk ("off: %d\n", off);
        printk ("start: %p\n\n", *start);
*/
        if (done) {
                c = 0;
                done = 0;
                *eof = 1;
                return 0;
        }

        if (c == 0) {
                if (rbuf_len == RBUF_LEN)
                        s = rbuf_start;
                else s = 0;
        }

        for (i=0; i<count && c<rbuf_len; i++, c++) {
                page[i] = rbuf[(c+s) % RBUF_LEN];
        }
        *start = page;
        
        if (c >= rbuf_len) {
                *eof = 1;
                done = 1;
        }


        return i;
}

static int __init init (void)
{

        int retval = 0;

        pdir = proc_mkdir("isoc_test", NULL);
        if(pdir == NULL) {
                retval = -ENOMEM;
                printk("Error creating dir\n");
                goto done;
        }
        pdir->owner = THIS_MODULE;

        pfile = create_proc_read_entry("isoc_data",
                                       0444, pdir,
                                       isoc_read_data,
                                       NULL);
        if (pfile == NULL) {
                retval = -ENOMEM;
                printk("Error creating file\n");
                goto no_file;
        }
        pfile->owner = THIS_MODULE;

        return usb_gadget_register_driver (&zero_driver);

 no_file:
        remove_proc_entry("isoc_data", NULL);
 done:
        return retval;
}
module_init (init);

static void __exit cleanup (void)
{

        usb_gadget_unregister_driver (&zero_driver);
        
        remove_proc_entry("isoc_data", pdir);
        remove_proc_entry("isoc_test", NULL);
}
module_exit (cleanup);