Qortal/Brooklyn
3
0
Fork 1
mirror of https://github.com/Qortal/Brooklyn.git synced 2025-01-31 15:22:18 +00:00
Code Issues Projects Releases Wiki Activity
7d3018da4c
Brooklyn/drivers/usb/host/dwc_otg/dummy_audio.c
Scare Crowe 105fe4b2bf initial commit
2021-05-27 00:09:36 +05:00

1575 lines
41 KiB
C
Raw Blame History

/*
* 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 = kzalloc (sizeof *dev, SLAB_KERNEL);
if (!dev)
return -ENOMEM;
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);
Reference in New Issue View Git Blame Copy Permalink