--- /dev/null
+/home/sl/USB/PB1500/work/usbd-gpl/kits/amd-pb1x00-kit/amd-pb1x00-linux-2.4.21
+diff -Nru a/arch/mips/config-shared.in b/arch/mips/config-shared.in
+--- a/arch/mips/config-shared.in Fri Feb 27 14:22:51 2004
++++ b/arch/mips/config-shared.in Fri Feb 27 14:22:51 2004
+@@ -985,6 +985,7 @@
+ endmenu
+
+ source drivers/usb/Config.in
++source drivers/usbd/Config.in
+
+ source net/bluetooth/Config.in
+
+--- a/drivers/Makefile 2005-08-15 18:51:50.332030952 +0200
++++ b/drivers/Makefile 2005-08-15 18:53:08.938081016 +0200
+@@ -41,6 +41,7 @@
+ subdir-$(CONFIG_ISDN_BOOL) += isdn
+ subdir-$(CONFIG_ATM) += atm
+ subdir-$(CONFIG_FC4) += fc4
++subdir-$(CONFIG_USBD) += usbd
+
+ # CONFIG_HAMRADIO can be set without CONFIG_NETDEVICE being set -- ch
+ subdir-$(CONFIG_HAMRADIO) += net/hamradio
+diff -Nru a/drivers/usbd/Config.in b/drivers/usbd/Config.in
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/Config.in Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,58 @@
++#
++# USB device configuration from the device viewpoint (e.g. Linux running inside a USB device, not as host)
++#
++# Copyright (c) 2002-2003 Belcarra
++#
++#
++
++mainmenu_option next_comment
++
++comment 'USB clients (devices, not hosts)'
++
++tristate 'Support for USB Clients (USB Device, not USB Host)' CONFIG_USBD
++
++if [ "$CONFIG_USBD" = "y" -o "$CONFIG_USBD" = "m" ]; then
++ comment ''
++ bool ' Enable High Speed Descriptors' CONFIG_USBD_HIGH_SPEED
++
++ bool ' Do Not Use Serial Number in Device Descriptor (Default is no' CONFIG_USBD_NO_SERIAL_NUMBER
++ if [ "$CONFIG_USBD_NO_SERIAL_NUMBER" != "y" ]; then
++ string ' Default Serial number (string)' CONFIG_USBD_SERIAL_NUMBER_STR ""
++ fi
++
++ int ' Max Power (mA) (Default is zero, whick is self powered)' CONFIG_USBD_MAXPOWER "0"
++
++ comment ''
++
++ bool ' USBD Proc FS' CONFIG_USBD_PROCFS
++
++ tristate ' USBD Proc FS Module' CONFIG_USBD_PROCFSM $CONFIG_USBD
++
++ comment 'Function Drivers'
++
++ source drivers/usbd/network_fd/Config.in
++ source drivers/usbd/acm_fd/Config.in
++
++ source drivers/usbd/mouse_fd/Config.in
++
++ comment 'Bus Interface'
++
++ source drivers/usbd/au1x00_bi/Config.in
++
++ bool ' USB Device Register Tracing' CONFIG_USBD_BI_REGISTER_TRACE
++ if [ "$CONFIG_USBD" = "y" ]; then
++ bool ' USB Device Manual Enable' CONFIG_USBD_BI_DELAY_ENABLE
++ fi
++
++
++ #source drivers/usbd/l7205_bi/Config.in
++ #source drivers/usbd/sl11_bi/Config.in
++
++ #source drivers/usbd/cdc_fd/Config.in
++ #source drivers/usbd/serialnumber/Config.in
++ #source drivers/usbd/audio_fd/Config.in
++ #source drivers/usbd/eg_fd/Config.in
++ #source drivers/usbd/keyboard_fd/Config.in
++fi
++
++endmenu
+diff -Nru a/drivers/usbd/Makefile b/drivers/usbd/Makefile
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/Makefile Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,157 @@
++#
++# Makefile for the kernel USBD (device not host) drivers.
++#
++# Copyright (c) 2002 Belcarra
++# Copyright (C) 2001 Lineo, Inc.
++# Copyright (C) 2001 Hewlett-Packard Co.
++
++# Subdirs.
++# This is a bit complex, because some subdirs are for
++# proprietary code, and are simply not present in a
++# general distribution.
++
++TOPDIR ?= ../../..
++
++# The all-CAPS *_DIRS get nuked in the new versions
++# of Rules.make, so use only the subdir-* methods.
++subdir-y :=
++subdir-m :=
++subdir-n :=
++subdir- :=
++
++# Function Drivers
++subdir-$(CONFIG_USBD_ACM) += acm_fd
++subdir-$(CONFIG_USBD_MOUSE) += mouse_fd
++subdir-$(CONFIG_USBD_NETWORK) += network_fd
++
++#subdir-$(CONFIG_USBD_AUDIO) += audio_fd
++#subdir-$(CONFIG_USBD_EG) += eg_fd
++#subdir-$(CONFIG_USBD_KEYBOARD) += keyboard_fd
++#subdir-$(CONFIG_USBD_CDC) += cdc_fd
++
++# Bus Interface Drivers
++subdir-$(CONFIG_USBD_AU1X00_BUS) += au1x00_bi
++
++#subdir-$(CONFIG_USBD_OMAP_BUS) += omap_bi
++#subdir-$(CONFIG_USBD_TC86C001_BUS) += tc86c001_bi
++
++#subdir-$(CONFIG_USBD_SL11_BUS) += sl11_bi
++
++# The target object and module list name.
++
++O_TARGET := usbdev.o
++
++# Objects that export symbols.
++
++export-objs := usbd.o usbd-bops.o usbd-fops.o usbd-bi.o ep0.o
++
++# Multipart objects.
++
++list-multi := usbdcore.o
++usbdcore-objs := usbd.o ep0.o usbd-fops.o usbd-bops.o
++usbdprocfs-objs := usbd-procfs.o
++
++
++# Optional parts of multipart objects.
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_USBD) += usbdcore.o
++obj-$(CONFIG_USBD_PROCFSM) += usbdprocfs.o
++
++# Object files in subdirectories
++
++#
++obj-$(CONFIG_USBD_MONITOR) += monitor/monitor.o
++
++obj-$(CONFIG_USBD_ACM) += acm_fd/acm_fd.o
++obj-$(CONFIG_USBD_MOUSE) += mouse_fd/mouse_fd.o
++obj-$(CONFIG_USBD_NETWORK) += network_fd/network_fd.o
++
++#obj-$(CONFIG_USBD_AUDIO) += audio_fd/audio_fd.o
++#obj-$(CONFIG_USBD_EG) += eg_fd/eg_fd.o
++#obj-$(CONFIG_USBD_KEYBOARD) += keyboard_fd/keyboard_fd.o
++
++# Bus Interface Drivers
++obj-$(CONFIG_USBD_AU1X00_BUS) += au1x00_bi/au1x00_bi.o
++
++#obj-$(CONFIG_USBD_OMAP_BUS) += omap_bi/omap_bi.o
++#obj-$(CONFIG_USBD_TC86C001_BUS) += tc86c001_bi/tc86c001_bi.o
++
++#obj-$(CONFIG_USBD_SL11_BUS) += sl11_bi/sl11_bi.o
++
++
++# Yech. This isn't the best way to do this, but there isn't a config flag
++# common to all the possible bus interfaces
++
++
++# Extract lists of the multi-part drivers.
++# The 'int-*' lists are the intermediate files used to build the multi's.
++
++multi-y := $(filter $(list-multi), $(obj-y))
++multi-m := $(filter $(list-multi), $(obj-m))
++int-y := $(sort $(foreach m, $(multi-y), $($(basename $(m))-objs)))
++int-m := $(sort $(foreach m, $(multi-m), $($(basename $(m))-objs)))
++
++# Files that are both resident and modular: remove from modular.
++
++obj-m := $(filter-out $(obj-y), $(obj-m))
++int-m := $(filter-out $(int-y), $(int-m))
++
++# Translate to Rules.make lists.
++
++O_OBJS := $(filter-out $(export-objs), $(obj-y))
++OX_OBJS := $(filter $(export-objs), $(obj-y))
++M_OBJS := $(sort $(filter-out $(export-objs), $(obj-m)))
++MX_OBJS := $(sort $(filter $(export-objs), $(obj-m)))
++MI_OBJS := $(sort $(filter-out $(export-objs), $(int-m)))
++MIX_OBJS := $(sort $(filter $(export-objs), $(int-m)))
++
++# The global Rules.make.
++
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -Wno-format -Wall
++
++# Link rules for multi-part drivers.
++
++usbdprocfs.o: $(usbdprocfs-objs)
++ $(LD) -r -o $@ $(usbdprocfs-objs)
++
++usbdcore.o: $(usbdcore-objs)
++ $(LD) -r -o $@ $(usbdcore-objs)
++
++# dependencies:
++
++usbd.o: usbd-build.h
++
++usbd-build.h:
++ echo "#define USBD_BUILD \"000\"" > $@
++
++# local
++
++%.h:%.p
++ release inc build < $< > $@
++ cp $@ $<
++
++release.h: release.p
++
++inc-build:
++ release inc build < release.p > release.h
++ cp release.h release.p
++
++
++menuconfig:
++ cd $(TOPDIR); make menuconfig
++
++xconfig:
++ cd $(TOPDIR); make xconfig
++
++
++
+diff -Nru a/drivers/usbd/acm_fd/Config.in b/drivers/usbd/acm_fd/Config.in
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/acm_fd/Config.in Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,27 @@
++#
++# CDC ACM Function Driver
++#
++# Copyright (C) 2003,2004 Belcarra
++#
++
++mainmenu_option next_comment
++comment "CDC ACM Function"
++
++dep_tristate ' CDC ACM Function' CONFIG_USBD_ACM $CONFIG_USBD
++if [ "$CONFIG_USBD_ACM" = "y" -o "$CONFIG_USBD_ACM" = "m" ]; then
++ hex 'VendorID (hex value)' CONFIG_USBD_ACM_VENDORID "12b9"
++ hex 'ProductID (hex value)' CONFIG_USBD_ACM_PRODUCTID "f002"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_USBD_ACM_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_USBD_ACM_MANUFACTURER "Belcarra"
++ string 'iProduct (string)' CONFIG_USBD_ACM_PRODUCT_NAME "Belcarra ACM Device"
++
++ string 'iConfiguration (string)' CONFIG_USBD_ACM_DESC "Acm Cfg"
++ string 'Comm Interface iInterface (string)' CONFIG_USBD_ACM_COMM_INTF "Comm Intf"
++ string 'Data Interface iInterface (string)' CONFIG_USBD_ACM_DATA_INTF "Data Intf"
++
++ bool ' ACM Tracing' CONFIG_USBD_ACM_TRACE
++ comment ''
++fi
++
++endmenu
+diff -Nru a/drivers/usbd/acm_fd/Makefile b/drivers/usbd/acm_fd/Makefile
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/acm_fd/Makefile Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,65 @@
++#
++# Function driver for a CDC ACM USB Device
++#
++# Copyright (c) 2003 Belcarra
++
++# Multipart objects.
++
++O_TARGET := acm_fd.o
++list-multi := acm_fd.o
++
++acm_fd-objs := acm.o trace.o
++
++# Objects that export symbols.
++export-objs := acm.o
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_USBD_ACM) += acm_fd.o
++
++# Extract lists of the multi-part drivers.
++# The 'int-*' lists are the intermediate files used to build the multi's.
++
++multi-y := $(filter $(list-multi), $(obj-y))
++multi-m := $(filter $(list-multi), $(obj-m))
++int-y := $(sort $(foreach m, $(multi-y), $($(basename $(m))-objs)))
++int-m := $(sort $(foreach m, $(multi-m), $($(basename $(m))-objs)))
++
++# Files that are both resident and modular: remove from modular.
++
++obj-m := $(filter-out $(obj-y), $(obj-m))
++int-m := $(filter-out $(int-y), $(int-m))
++
++# Translate to Rules.make lists.
++
++O_OBJS := $(filter-out $(export-objs), $(obj-y))
++OX_OBJS := $(filter $(export-objs), $(obj-y))
++M_OBJS := $(sort $(filter-out $(export-objs), $(obj-m)))
++MX_OBJS := $(sort $(filter $(export-objs), $(obj-m)))
++MI_OBJS := $(sort $(filter-out $(export-objs), $(int-m)))
++MIX_OBJS := $(sort $(filter $(export-objs), $(int-m)))
++
++# The global Rules.make.
++
++USBD=$(TOPDIR)/drivers/usbd
++ACMD=$(USBD)/acm_fd
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -I$(ACMD) -I$(USBD) -Wno-unused -Wno-format
++EXTRA_CFLAGS_nostdinc += -I$(ACMD) -I$(USBD) -Wno-unused -Wno-format
++
++# Link rules for multi-part drivers.
++
++acm_fd.o: $(acm_fd-objs)
++ $(LD) -r -o $@ $(acm_fd-objs)
++
++# dependencies:
++
++acm.o: $(USBD)/usbd.h $(USBD)/usbd-bus.h $(USBD)/usbd-func.h
++
+diff -Nru a/drivers/usbd/acm_fd/acm.c b/drivers/usbd/acm_fd/acm.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/acm_fd/acm.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,1662 @@
++/*
++ * usbd/acm_fd/acm.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ * Note: this function driver requires the following endpoints:
++ *
++ * BULK-IN
++ * BULK-OUT
++ * INTERRUPT-IN
++ *
++ * This function driver cannot be used on devices (such as the StrongArm
++ * SA1100) that do not have and interrupt endpoint.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++
++MODULE_DESCRIPTION ("Belcarra CDC-ACM Function");
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("GPL");
++#endif
++
++#define ACM_TRACE_NAME "acm_trace"
++
++#undef USE_TICKER
++#undef MCEL
++//#define MCEL 1
++//#define CONFIG_USBD_ACM_DATALOG 1
++#undef CONFIG_USBD_ACM_DATALOG
++#undef PST_FD_AVAILABLE
++
++#include <linux/init.h>
++#include <asm/uaccess.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/interrupt.h>
++#include <asm/atomic.h>
++#include <linux/tty.h>
++#include <linux/tty_driver.h>
++#include <linux/tty_flip.h>
++#include <linux/smp_lock.h>
++#include <linux/slab.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++#include "trace.h"
++// Define the low order 16 bits of an urb's memory address as it's ID for tracing.
++#define urbID(urb) (0xffff & (u32) (void *) urb)
++int acm_interrupts;
++
++USBD_MODULE_INFO ("acm_fd 2.1-beta");
++
++#define MAX_QUEUED_BYTES 256
++#define MAX_QUEUED_URBS 10 // Max for write
++
++#define MAX_RECV_URBS 2 // Max for receiving data
++#define RECV_RING_SIZE (MAX_RECV_URBS+1)
++
++// Endpoint indexes in acm_endpoint_requests[] and the endpoint map.
++#define BULK_OUT 0x00
++#define BULK_IN 0x01
++#define INT_IN 0x02
++#if !defined(CONFIG_USBD_ACM_DATALOG)
++#define ENDPOINTS 0x03
++#else
++#define DATALOG_BULK_IN 0x03
++#define ENDPOINTS 0x04
++#endif
++
++#define COMM_INTF 0x00
++#define DATA_INTF 0x01
++#if defined(CONFIG_USBD_ACM_DATALOG)
++#define DATALOG_INTF 0x02
++#define TESTCMD_INTF 0x03
++#endif
++
++#if defined(CONFIG_USBD_ACM_DATALOG) && defined(PST_FD_AVAILABLE)
++extern int pst_dev_create(struct usb_device_instance *device);
++extern void pst_dev_destroy(void);
++extern void ep0_process_vendor_request( struct urb *urb );
++extern int pst_urb_sent (struct urb *urb, int rc);
++#endif
++
++/* Module Parameters ************************************************************************* */
++
++static u32 vendor_id;
++static u32 product_id;
++static u32 max_queued_urbs = MAX_QUEUED_URBS;
++static u32 max_queued_bytes = MAX_QUEUED_BYTES;
++
++MODULE_PARM (vendor_id, "i");
++MODULE_PARM (product_id, "i");
++MODULE_PARM (max_queued_urbs, "i");
++MODULE_PARM (max_queued_bytes, "i");
++
++MODULE_PARM_DESC (vendor_id, "Device Vendor ID");
++MODULE_PARM_DESC (product_id, "Device Product ID");
++MODULE_PARM_DESC (max_queued_urbs, "Maximum TX Queued Urbs");
++MODULE_PARM_DESC (max_queued_bytes, "Maximum TX Queued Bytes");
++
++/*
++ * CDC ACM Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/* Endpoints */
++static __u8 acm_alt_1[] = { 0x07, USB_DT_ENDPOINT, OUT, BULK, 0, 0x00, 0x00, };
++static __u8 acm_alt_2[] = { 0x07, USB_DT_ENDPOINT, IN, BULK, 0, 0x00, 0x00, };
++static struct usb_endpoint_descriptor *acm_alt_endpoints[] = {
++ (struct usb_endpoint_descriptor *) acm_alt_1,
++ (struct usb_endpoint_descriptor *) acm_alt_2, };
++u8 acm_alt_indexes[] = { BULK_OUT, BULK_IN, };
++
++static __u8 acm_comm_1[] = { 0x07, USB_DT_ENDPOINT, IN, INTERRUPT, 0, 0x00, 0x0a, };
++static struct usb_endpoint_descriptor *acm_comm_endpoints[] = { (struct usb_endpoint_descriptor *) acm_comm_1 };
++u8 acm_comm_indexes[] = { INT_IN, };
++
++static __u8 cdc_class_1[] = { 0x05, CS_INTERFACE, USB_ST_HEADER, 0x01, 0x01, /* CLASS_BDC_VERSION, CLASS_BDC_VERSION */ };
++static __u8 cdc_class_2[] = { 0x05, CS_INTERFACE, USB_ST_CMF, 0x03, 0x01, /* bMasterInterface: 0, bSlaveInterface: 1 */ };
++static __u8 cdc_class_3[] = { 0x05, CS_INTERFACE, USB_ST_UF, 0x00, 0x01, /* bMasterInterface: 0, bSlaveInterface: 1 */ };
++
++/* ACMF - c.f. Table 28
++ * currenty set to 0x2 - Support Set_Line_Coding etc,
++ *
++ * XXX Should we also set 0x4 - Supports Network_Notification?
++ */
++static __u8 cdc_class_4[] = { 0x04, CS_INTERFACE, USB_ST_ACMF, 0x02, };
++
++static struct usb_generic_class_descriptor *cdc_comm_class_descriptors[] =
++ { (struct usb_generic_class_descriptor *) cdc_class_1,
++ (struct usb_generic_class_descriptor *) cdc_class_2,
++ (struct usb_generic_class_descriptor *) cdc_class_3,
++ (struct usb_generic_class_descriptor *) cdc_class_4, };
++
++
++#if defined(CONFIG_USBD_ACM_DATALOG)
++
++#if 0
++/* This is used to get a specific INTERFACE number, by padding the list of interfaces. */
++static struct usb_alternate_description dummy_alternate_descriptions[] = {
++ { iInterface:"Dummy", },
++};
++#endif
++
++/* There is no way to request a specific ENDPOINT address, since that depends on
++ the bus interface hardware. */
++//#define DATA_LOG_IN_ENDPOINT 11
++
++static __u8 datalog_endpoint[] = {
++ 0x07, // bLength
++ USB_DT_ENDPOINT, // bDescriptorType // 0x5
++ /*DATA_LOG_IN_ENDPOINT |*/ IN, // bEndpointAddress
++ BULK, // bmAttributes
++ 0, 0x00, // wMaxPacketSize
++ 0x00, // bInterval
++};
++static struct usb_endpoint_descriptor *datalog_endpoints[] = { datalog_endpoint };
++u8 datalog_indexes[] = { DATALOG_BULK_IN, };
++
++
++// No endpoints needed for TestCmd interface.
++#endif
++
++/* Alternate Descriptors */
++// First two bytes are identical in all: bLength, bDescriptorType (0x09 0x04)
++static __u8 cdc_comm_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, COMM_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_ACM_SUBCLASS, 0x01, 0x00, };
++
++static __u8 cdc_data_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, DATA_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00, };
++
++
++#if defined(CONFIG_USBD_ACM_DATALOG)
++
++static __u8 datalog_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, DATALOG_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ // bInterfaceClass, bInterfaceSubClass, bInterfaceProtocol, iInterface
++ 0xFF, 0x02, 0xFF, 0x00, };
++
++static __u8 testcmd_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, TESTCMD_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ // bInterfaceClass, bInterfaceSubClass, bInterfaceProtocol, iInterface
++ 0xFF, 0x03, 0xFF, 0x00, };
++
++#endif
++
++/* Alternate Descriptions */
++static struct usb_alternate_description cdc_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_ACM_COMM_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usb_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++ endpoint_list: acm_comm_endpoints,
++ endpoints:sizeof (acm_comm_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_indexes: acm_comm_indexes,
++ }, };
++
++static struct usb_alternate_description cdc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_ACM_DATA_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&cdc_data_alternate_descriptor,
++ endpoint_list: acm_alt_endpoints,
++ endpoints:sizeof (acm_alt_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_indexes: acm_alt_indexes,
++ }, };
++
++#if defined(CONFIG_USBD_ACM_DATALOG)
++
++static struct usb_alternate_description datalog_alternate_descriptions[] = {
++ { iInterface:"Motorola MCU Data Logger",
++ interface_descriptor: (struct usb_interface_descriptor *)&datalog_alternate_descriptor,
++ endpoint_list: datalog_endpoints,
++ endpoints:sizeof (datalog_endpoints) / sizeof (struct usb_endpoint_descriptor *),
++ endpoint_indexes: datalog_indexes,
++ },
++};
++
++static struct usb_alternate_description testcmd_alternate_descriptions[] = {
++ { iInterface:"Motorola Test Command",
++ interface_descriptor: (struct usb_interface_descriptor *)&testcmd_alternate_descriptor,
++ },
++};
++#endif
++
++/* Interface Descriptions */
++static struct usb_interface_description cdc_interfaces[] = {
++ {
++ alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,
++ },
++
++ {
++ alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,
++ },
++
++#if defined(CONFIG_USBD_ACM_DATALOG)
++#if 0
++ // Space the INTERFACEs out by adding as many dummies as required (for now, none).
++ { alternate_list: dummy_alternate_descriptions, }, /* 0xN */
++#endif
++
++ { alternates:sizeof (datalog_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:datalog_alternate_descriptions,
++ },
++
++ { alternates:sizeof (testcmd_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:testcmd_alternate_descriptions,
++ },
++
++#endif
++
++};
++
++
++/* Configuration Descriptor and Description */
++static __u8 cdc_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, sizeof (cdc_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, BMATTRIBUTE, BMAXPOWER, };
++
++struct usb_configuration_description acm_description[] = {
++ { iConfiguration: CONFIG_USBD_ACM_DESC,
++ configuration_descriptor: (struct usb_configuration_descriptor *)cdc_configuration_descriptor,
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:cdc_interfaces,}, };
++
++static struct usb_device_descriptor acm_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_ACM_BCDDEVICE),
++};
++
++
++static struct usb_endpoint_request acm_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 1, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, 64, 512, },
++ { 1, 1, 0, USB_DIR_IN | USB_ENDPOINT_BULK, 64 /* * 4 */, 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT, 16, 64, },
++#if defined(CONFIG_USBD_ACM_DATALOG)
++ { 1, 1, 0, USB_DIR_IN | USB_ENDPOINT_BULK, 64, 512, },
++#endif
++ { 0, },
++};
++
++
++struct usb_device_description acm_device_description = {
++ device_descriptor: &acm_device_descriptor,
++ iManufacturer: CONFIG_USBD_ACM_MANUFACTURER,
++ iProduct: CONFIG_USBD_ACM_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: acm_endpoint_requests,
++};
++
++/* Missing atomic functions ******************************************************************** */
++
++static __inline__ int atomic_post_inc(volatile atomic_t *v)
++{
++ unsigned long flags;
++ int result;
++ local_irq_save(flags);
++ result = (v->counter)++;
++ local_irq_restore(flags);
++ return(result);
++}
++
++static __inline__ int atomic_pre_dec(volatile atomic_t *v)
++{
++ unsigned long flags;
++ int result;
++ local_irq_save(flags);
++ result = --(v->counter);
++ local_irq_restore(flags);
++ return(result);
++}
++
++/* ACM ***************************************************************************************** */
++/*
++ * Output and Input control lines and line errors.
++ */
++#define LINE_OUT_DTR 0x01
++#define LINE_OUT_RTS 0x02
++#define LINE_IN_DCD 0x01
++#define LINE_IN_DSR 0x02
++#define LINE_IN_BRK 0x04
++#define LINE_IN_RI 0x08
++#define LINE_IN_FRAMING 0x10
++#define LINE_IN_PARITY 0x20
++#define LINE_IN_OVERRUN 0x40
++
++/* ******************************************************************************************* */
++
++#define ACM_TTY_MAJOR 166
++#define ACM_TTY_MINOR 0
++#define ACM_TTY_MINORS 1
++
++struct acm_private {
++ struct usb_function_instance *function;
++ struct tty_driver *tty_driver;
++ int tty_driver_registered; // non-zero if tty_driver registered
++ int usb_driver_registered; // non-zero if usb function registered
++
++ struct tty_struct *tty; // non-null if tty open
++ struct tq_struct wqueue; // task queue for writer wakeup
++ struct tq_struct hqueue; // task queue for hangup
++ wait_queue_head_t open_wait; // wait queue for blocking open
++ int open_wait_count; // count of (possible) blocked
++ int exiting; // True if module exiting
++
++ unsigned char throttle; // non-zero if we are throttled
++ unsigned char clocal; // non-zero if clocal set
++ unsigned char connected; // non-zero if connected to host (configured)
++
++ unsigned int writesize; // packetsize * 4
++ unsigned int ctrlin; // line state device sends to host
++ unsigned int ctrlout; // line state device received from host
++
++ int exclusive;
++ atomic_t used;
++ atomic_t queued_bytes;
++ atomic_t queued_urbs;
++
++ /*TBR debug receive flow control */
++ unsigned long bytes_received;
++ unsigned long bytes_forwarded;
++ /*TBR end debug */
++
++ struct urb *recv_ring[RECV_RING_SIZE];
++ unsigned int rr_in_ndx;
++ unsigned int rr_out_ndx;
++
++ struct urb *int_urb; // pending interrupt urb
++};
++
++static struct acm_private acm_private;
++
++static int acm_send_int_notification(struct usb_function_instance *, int , int );
++static int acm_urb_sent_bulk (struct urb *urb, int rc);
++static int acm_urb_sent_int (struct urb *urb, int rc);
++static int acm_recv_urb (struct urb *urb, int rc);
++
++/* Serial Functions **************************************************************************** */
++
++static void acm_schedule(struct tq_struct *queue)
++{
++ TRACE_MSG1("task %p",queue);
++ RETURN_IF(!queue->data || queue->sync);
++ MOD_INC_USE_COUNT;
++ queue_task(queue, &tq_immediate);
++ mark_bh(IMMEDIATE_BH);
++ TRACE_MSG1("task %p scheduled and marked",queue);
++}
++
++
++static int block_until_ready(
++ struct tty_struct *tty,
++ struct file *filp,
++ struct acm_private *acm)
++{
++ unsigned long flags;
++ int rc = 0;
++
++ // FUTURE: check tty for non-blocking open...
++
++ local_irq_save(flags);
++ TRACE_MSG1("owc=%d --> at entry",acm->open_wait_count);
++ acm->open_wait_count += 1;
++ for (;;) {
++ if (tty_hung_up_p(filp)) {
++ TRACE_MSG("tty_hung_up_p()");
++ rc = -ERESTARTSYS;
++ break;
++ }
++ if (signal_pending(current)) {
++ TRACE_MSG("signal_pending()");
++ rc = -ERESTARTSYS;
++ break;
++ }
++ if (acm->exiting) {
++ TRACE_MSG("module exiting()");
++ rc = -ENODEV;
++ break;
++ }
++ if (acm->ctrlout & LINE_OUT_DTR) {
++ // OK, there's somebody on the other end, let's go...
++ TRACE_MSG("found DTR");
++ break;
++ }
++ TRACE_MSG1("owc=%d sleeping...",acm->open_wait_count);
++ interruptible_sleep_on(&acm->open_wait);
++ TRACE_MSG1("owc=%d got WAKEUP",acm->open_wait_count);
++ }
++ acm->open_wait_count -= 1;
++ TRACE_MSG1("owc=%d <-- at exit",acm->open_wait_count);
++ local_irq_restore(flags);
++ return(rc);
++}
++
++static void acm_hangup(void *private)
++{
++ //struct acm_private *acm = &acm_private;
++ struct acm_private *acm = (struct acm_private *) private;
++ struct tty_struct *tty = acm->tty;
++ TRACE_MSG("entered");
++
++ if (tty && !acm->clocal)
++ tty_hangup(tty);
++
++ wake_up_interruptible(&acm->open_wait);
++
++ MOD_DEC_USE_COUNT;
++ //printk (KERN_INFO"%s: MOD: %d connected: %d tty: %p clocal: %x\n",
++ // __FUNCTION__, MOD_IN_USE, acm->connected, tty, acm->clocal);
++ TRACE_MSG("exited");
++}
++
++static int acm_tty_open(struct tty_struct *tty, struct file *filp)
++{
++ struct acm_private *acm = &acm_private;
++ //struct usb_function_instance *function = acm->function;
++ int used;
++ int nonblocking;
++ int rc = 0;
++ unsigned long flags;
++
++ TRACE_MSG2("used=%d MOD=%d",atomic_read(&acm->used),MOD_IN_USE);
++ //printk (KERN_INFO"%s: bus: %p used: %d MOD: %d\n",
++ // __FUNCTION__, acm->function, atomic_read(&acm->used), MOD_IN_USE);
++ nonblocking = filp->f_flags & O_NONBLOCK;
++ /* Lock and increment used counter, save current value.
++ Check for exclusive open at the same time. */
++ local_irq_save(flags);
++ /* The value of acm->used controls MOD_{INC/DEC}_USE_COUNT, so
++ it has to be incremented unconditionally, and no early return
++ made until after USE_COUNT has been adjusted to match. */
++ used = atomic_post_inc(&acm->used);
++#ifdef MCEL
++ filp->f_flags |= O_EXCL; // QQQ Can we persuade MCEL to add this to their app?
++ if (nonblocking && !(acm->connected)) {
++ // QQQ Is MCEL actually using this "feature"? (See below for printk)
++ rc = -EINVAL;
++ } else
++#endif
++ if (filp->f_flags & O_EXCL) {
++ /* This is intended to be an exclusive open, so
++ make sure no one has the device open already, and
++ set the exclusive flag so no one can open it later. */
++ if (used > 0) {
++ // Someone already has it.
++ rc = -EBUSY;
++ } else {
++ acm->exclusive = 1;
++ set_bit(TTY_EXCLUSIVE, &tty->flags);
++ }
++ } else if (acm->exclusive != 0 && !suser()) {
++ // Only the superuser can do a normal open of an O_EXCL tty
++ rc = -EBUSY;
++ }
++ local_irq_restore(flags);
++ if (0 == used) {
++ // The value before incrementing was 0, this is the first open.
++ MOD_INC_USE_COUNT;
++ }
++ // OK, now it's safe to make an early return.
++ if (0 != rc) {
++#ifdef MCEL
++ // This can dissappear when the "feature" above does.
++ if (-EINVAL == rc)
++ printk(KERN_INFO "\nusb cable not connected!\n");
++#endif
++ return(rc);
++ }
++ /* To truly emulate the old dual-device approach of having a non-blocking
++ device (e.g cu0) and a blocking device (e.g. tty0) we would need to
++ track blocking and non-blocking opens separately. We don't. This
++ may lead to funny behavior in the multiple open case. */
++ if (0 == used) {
++ // First open.
++ TRACE_MSG2("FIRST OPEN nb=%x xo=%x",nonblocking,acm->exclusive);
++ //printk (KERN_INFO"%s: FIRST OPEN used_%sblock: s=%d, a=%d x=%d\n",
++ // __FUNCTION__,(nonblocking?"non":""), used, atomic_read(&acm->used),
++ // acm->exclusive);
++ tty->driver_data = acm;
++ acm->tty = tty;
++ tty->low_latency = 1;
++ acm->bytes_received = 0;
++ acm->bytes_forwarded = 0;
++ acm->ctrlin = LINE_IN_DCD | LINE_IN_DSR;
++ if (NULL != acm->function) {
++ TRACE_MSG1("sending notification ctrlin=%x",acm->ctrlin);
++ //printk (KERN_INFO"%s: sending ctrlin notification\n",__FUNCTION__);
++ rc = acm_send_int_notification(acm->function, CDC_NOTIFICATION_SERIAL_STATE,
++ acm->ctrlin);
++ }
++ }
++
++ if (0 == rc && !nonblocking) {
++ // Blocking open - all callers block until DTR shows up.
++ rc = block_until_ready(tty,filp,acm);
++ }
++
++ /* The tty layer calls acm_tty_close() even if this open fails,
++ so any cleanup (rc != 0) will be done there. */
++ TRACE_MSG2("used=%d rc=%d",atomic_read(&acm->used),rc);
++ return(rc);
++}
++
++static void acm_tty_close(struct tty_struct *tty, struct file *filp)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct usb_function_instance *function = acm->function;
++ int used;
++
++ TRACE_MSG2("used=%d MOD=%d",atomic_read(&acm->used),MOD_IN_USE);
++ //printk (KERN_INFO"%s: function: %p used: %d MOD: %d\n",
++ // __FUNCTION__, function, atomic_read(&acm->used), MOD_IN_USE);
++
++ // lock and decrement used counter, save result
++ used = atomic_pre_dec(&acm->used);
++
++ // finished unless this is the last close
++ if (used <= 0) {
++ // This is the last close, clean up
++
++ acm->tty = NULL;
++ acm->ctrlin = 0x0;
++
++ if (acm->function) {
++ acm_send_int_notification(function, CDC_NOTIFICATION_SERIAL_STATE, acm->ctrlin);
++ }
++ /* This should never happen if this is the last close,
++ but it can't hurt to check. */
++ if (acm->open_wait_count) {
++ wake_up_interruptible(&acm->open_wait);
++ }
++ if (acm->exclusive) {
++ acm->exclusive = 0;
++ clear_bit(TTY_EXCLUSIVE, &tty->flags);
++ }
++ MOD_DEC_USE_COUNT;
++ TRACE_MSG1("LAST CLOSE r-f=%d",(acm->bytes_received-acm->bytes_forwarded));
++ //printk (KERN_INFO"%s: LAST CLOSE used: %d MOD: %d bytes_received: %lu forwarded: %lu\n",
++ // __FUNCTION__, atomic_read(&acm->used), MOD_IN_USE, acm->bytes_received,
++ // acm->bytes_forwarded);
++ }
++ TRACE_MSG("exited");
++}
++
++/* Transmit Function - called by serproto ****************************************************** */
++
++static int acm_tty_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct usb_function_instance *function = acm->function;
++ struct urb *urb;
++
++ TRACE_MSG1("count=%d",count);
++ //printk (KERN_INFO"%s: used: %d count: %d\n", __FUNCTION__, atomic_read(&acm->used), count);
++
++ RETURN_EINVAL_IF(!function);
++ TRACE_MSG("function OK");
++
++ // sanity check and are we connect
++ RETURN_EINVAL_IF(!atomic_read(&acm->used));
++ TRACE_MSG("used OK");
++ RETURN_ZERO_IF (!count || !acm->connected);
++ TRACE_MSG("connected OK");
++ RETURN_ZERO_IF(max_queued_urbs <= atomic_read(&acm->queued_urbs));
++ TRACE_MSG("max_queued_urbs OK");
++
++ // allocate a write urb
++ count = MIN(count, acm->writesize);
++
++ // XXX verify that we don't attempt to send wMaxPacketSize packets...
++ if (!(count % usbd_endpoint_wMaxPacketSize(function, BULK_OUT, 0))) //QQSV
++ count--;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ RETURN_ENOMEM_IF (!(urb = usbd_alloc_urb (function, BULK_IN, count, acm_urb_sent_bulk)));
++ TRACE_MSG("alloc_urb OK");
++
++ if (from_user)
++ copy_from_user(urb->buffer, buf, count);
++ else
++ memcpy(urb->buffer, buf, count);
++ urb->privdata = acm;
++ urb->actual_length = count;
++ atomic_add(count, &acm->queued_bytes);
++ atomic_inc(&acm->queued_urbs);
++ usbd_send_urb(urb);
++ TRACE_MSG2("urbID#%04x --> %d",urbID(urb),count);
++ return count;
++}
++
++static int acm_tty_write_room(struct tty_struct *tty)
++{
++ struct acm_private *acm = &acm_private;
++ int rc;
++
++ TRACE_MSG("entered");
++ //printk (KERN_INFO"%s: used: %d queued: %d %d room: %d\n", __FUNCTION__, atomic_read(&acm->used),
++ // atomic_read(&acm->queued_urbs), atomic_read(&acm->queued_bytes),
++ // (max_queued_urbs > atomic_read(&acm->queued_urbs)) &&
++ // (max_queued_bytes > atomic_read(&acm->queued_bytes)) ? acm->writesize : 0);
++
++ RETURN_EINVAL_IF(!atomic_read(&acm->used));
++ TRACE_MSG("used OK");
++ rc = (!acm->function || max_queued_urbs <= atomic_read(&acm->queued_urbs) ||
++ max_queued_bytes <= atomic_read(&acm->queued_bytes) ) ? 0 : acm->writesize ;
++ TRACE_MSG1("--> %d",rc);
++ return(rc);
++}
++
++static int acm_tty_chars_in_buffer(struct tty_struct *tty)
++{
++ struct acm_private *acm = &acm_private;
++ int rc;
++ TRACE_MSG("entered");
++ RETURN_EINVAL_IF(!atomic_read(&acm->used));
++ TRACE_MSG("used OK");
++ RETURN_ZERO_IF(!acm->function);
++ TRACE_MSG("function OK");
++ rc = atomic_read(&acm->queued_bytes);
++ TRACE_MSG1("--> %d",rc);
++ return(rc);
++}
++
++static struct urb *acm_frwd_recv_urbs(struct tty_struct *tty, struct acm_private *acm)
++{
++ unsigned long flags;
++ struct urb *urb;
++
++ TRACE_MSG("entered");
++ //struct usb_function_instance *function = acm->function;
++
++ //if (acm->throttle)
++ // printk(KERN_INFO"%s: THROTTLED at 0\n", __FUNCTION__);
++
++ while (acm->rr_in_ndx != acm->rr_out_ndx && !acm->throttle) {
++ // Forward one URB from the receive ring
++ local_irq_save(flags);
++ urb = acm->recv_ring[acm->rr_out_ndx];
++ acm->recv_ring[acm->rr_out_ndx] = NULL;
++ acm->rr_out_ndx = (acm->rr_out_ndx + 1) % RECV_RING_SIZE;
++ local_irq_restore(flags);
++
++ if (urb->status == RECV_OK && tty) {
++ unsigned char *cp = urb->buffer;
++ int i;
++ int f = 0;
++ // Future: think about throttle part way through...
++ //printk(KERN_INFO"%s: ", __FUNCTION__);
++#define ACM_WORD_COPY
++#ifndef ACM_WORD_COPY
++ for (i = 0; i < urb->actual_length; i++) {
++ if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
++ tty_flip_buffer_push(tty);
++ acm->bytes_forwarded += f;
++ f = 0;
++ }
++
++ //printk("%02x ", *cp);
++ tty_insert_flip_char(tty, *cp++, 0);
++ f += 1;
++
++ if (acm->throttle) {
++ //printk(KERN_INFO"%s: throttled at %d/%d\n", __FUNCTION__,i,urb->actual_length);
++ break;
++ }
++ }
++ //printk("\n");
++ tty_flip_buffer_push(tty);
++ acm->bytes_forwarded += f;
++#else
++ for (i = urb->actual_length; i > 0; i -= f) {
++ f = i;
++ if (tty->flip.count + f > TTY_FLIPBUF_SIZE) {
++ tty_flip_buffer_push(tty);
++ f = MIN(f, TTY_FLIPBUF_SIZE - tty->flip.count);
++ }
++ if (f <= 0) {
++ // Shouldn't happen...
++ printk(KERN_ERR"%s: %d bytes dropped\n", __FUNCTION__, i);
++ break;
++ }
++ memcpy(tty->flip.char_buf_ptr, cp, f); // see: arch/arm/lib/memcpy.S
++ cp += f;
++ tty->flip.count += f;
++ tty->flip.flag_buf_ptr += f;
++ tty->flip.char_buf_ptr += f; // w20146 - Jul 31
++ tty_flip_buffer_push(tty);
++ acm->bytes_forwarded += f;
++ }
++
++#endif
++ if (acm->throttle) {
++ printk(KERN_INFO"%s: THROTTLED at 1\n", __FUNCTION__);
++ }
++ }
++ else if (urb->status != RECV_OK)
++ printk(KERN_INFO"%s: !RECV_OK, dumping %d bytes\n", __FUNCTION__,urb->actual_length);
++ else
++ printk(KERN_INFO"%s: tty NULL\n", __FUNCTION__);
++
++ // Put urb back in line for a refill.
++ if (usbd_start_recv (urb)) {
++ // Bail if it can't be queued for refill.
++ printk(KERN_INFO"%s: usbd_start_recv() failed\n", __FUNCTION__);
++ return(urb);
++ }
++ }
++ TRACE_MSG("exited");
++ return(NULL);
++}
++
++static void acm_tty_throttle(struct tty_struct *tty)
++{
++ struct acm_private *acm = &acm_private;
++ TRACE_MSG("entered");
++ //uuu printk (KERN_INFO"%s:\n", __FUNCTION__);
++ if (acm && atomic_read(&acm->used))
++ acm->throttle = 1;
++ TRACE_MSG("exited");
++}
++
++static void acm_tty_unthrottle(struct tty_struct *tty)
++{
++ struct acm_private *acm = &acm_private;
++ struct urb *urb;
++ TRACE_MSG("entered");
++ //uuu printk (KERN_INFO"%s:\n", __FUNCTION__);
++ if (acm && atomic_read(&acm->used)) {
++ acm->throttle = 0;
++ // Forward any queued URBS.
++ if (NULL != (urb = acm_frwd_recv_urbs(tty,acm))) {
++ /* usbd_start_recv(urb) failed, so we need to dispose of this urb.
++ Count on someone else to replace it. */
++ usbd_dealloc_urb(urb);
++ }
++ }
++ TRACE_MSG("exited");
++}
++
++static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
++{
++ struct acm_private *acm = &acm_private;
++ struct usb_function_instance *function = acm->function;
++ unsigned int mask;
++ unsigned int newctrl;
++
++ TRACE_MSG("entered");
++ //printk (KERN_INFO"%s: used: %d\n", __FUNCTION__, atomic_read(&acm->used));
++ RETURN_EINVAL_IF(!atomic_read(&acm->used));
++
++#if 1 // temporary solution for IOCTL
++ if(cmd == TIOCMGET)
++ return put_user( acm->ctrlout & LINE_OUT_DTR ? TIOCM_DTR : 0 | TIOCM_CTS, (unsigned long *) arg);
++#endif
++
++ TRACE_MSG("--> -ENOIOCTLCMD");
++ return -ENOIOCTLCMD;
++
++#if 0
++ switch(cmd) {
++ case TCGETS:
++ case TCFLSH:
++ case TCSETS:
++ printk (KERN_INFO"%s: ignored cmd: %x\n", __FUNCTION__, cmd);
++ return 0;
++
++ case TCSETSW:
++
++ //user_termios_to_kernel_termios(&priv->termios, (struct termios *)arg);
++ printk (KERN_INFO"%s: ignored cmd: %x\n", __FUNCTION__, cmd);
++ return 0;
++
++ case TIOCMGET:
++ printk (KERN_INFO"%s: TIOCMGET: %04x\n", __FUNCTION__, acm->ctrlin & LINE_OUT_DTR ? TIOCM_DTR : 0 | TIOCM_CTS);
++ return put_user( acm->ctrlin & LINE_OUT_DTR ? TIOCM_DTR : 0 | TIOCM_CTS, (unsigned long *) arg);
++
++ case TIOCMSET:
++ case TIOCMBIS:
++ case TIOCMBIC:
++
++ printk (KERN_INFO"%s: TIOCM{SET,BIS,BIC}:\n", __FUNCTION__);
++ RETURN_EFAULT_IF (get_user(mask, (unsigned long *) arg));
++
++ printk (KERN_INFO"%s: TIOCM{SET,BIS,BIC}: %04x\n", __FUNCTION__, mask);
++
++ newctrl = acm->ctrlin;
++
++ mask = (mask & TIOCM_DTR ? LINE_IN_DCD|LINE_IN_DSR : 0)/* | (mask & TIOCM_RTS ? LINE_OUT_RTS : 0)*/;
++
++ switch(cmd) {
++ case TIOCMSET: newctrl = mask; break;
++ case TIOCMBIS: newctrl |= mask; break;
++ case TIOCMBIC: newctrl &= mask; break;
++ }
++ RETURN_ZERO_IF(acm->ctrlin == newctrl);
++
++ printk (KERN_INFO"%s: newctrl: %04x\n", __FUNCTION__, newctrl);
++ return acm_send_int_notification(function, CDC_NOTIFICATION_SERIAL_STATE, acm->ctrlin);
++
++ case 3:
++ return 0;
++ default:
++ printk (KERN_INFO"%s: unknown: %04x\n", __FUNCTION__, cmd);
++ break;
++ }
++ return -ENOIOCTLCMD;
++#endif
++}
++
++static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
++{
++ struct acm_private *acm = &acm_private;
++ struct termios *termios;
++
++ TRACE_MSG("entered");
++ //printk (KERN_INFO"%s: tty: %p\n", __FUNCTION__, tty);
++
++ RETURN_IF(!atomic_read(&acm->used) || !tty || !tty->termios);
++
++ termios = tty->termios;
++ acm->clocal = termios->c_cflag & CLOCAL;
++
++ //printk (KERN_INFO"%s: clocal: %d\n", __FUNCTION__, acm->clocal);
++ TRACE_MSG("exited");
++}
++
++/* ********************************************************************************************* */
++
++static void acm_wakeup_writers(void *private)
++{
++ struct acm_private *acm = &acm_private;
++ struct tty_struct *tty = acm->tty;
++
++ TRACE_MSG("entered");
++ MOD_DEC_USE_COUNT;
++
++ //printk (KERN_INFO"%s: MOD: %d connected: %d tty: %p\n", __FUNCTION__, MOD_IN_USE, acm->connected, tty);
++
++ RETURN_IF(!acm->connected || !atomic_read(&acm->used) || !tty);
++ TRACE_MSG("connected and used OK");
++
++ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
++ TRACE_MSG("ldisc wakeup");
++ (tty->ldisc.write_wakeup)(tty);
++ }
++
++ // printk (KERN_INFO"%s: write_wait wakeup\n", __FUNCTION__);
++ wake_up_interruptible(&tty->write_wait);
++ TRACE_MSG("exited");
++}
++
++
++/* ********************************************************************************************* */
++
++static int acm_tty_refcount;
++static struct tty_struct *acm_tty_table[ACM_TTY_MINORS];
++static struct termios *acm_tty_termios[ACM_TTY_MINORS];
++static struct termios *acm_tty_termios_locked[ACM_TTY_MINORS];
++
++static struct tty_driver acm_tty_driver = {
++ magic: TTY_DRIVER_MAGIC,
++ type: TTY_DRIVER_TYPE_SERIAL,
++ subtype: SERIAL_TYPE_NORMAL,
++ flags: TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
++ driver_name: "acm-CDC",
++ name: "usb/acm/%d",
++ major: ACM_TTY_MAJOR,
++ num: ACM_TTY_MINORS,
++ minor_start: 0,
++
++ open: acm_tty_open,
++ close: acm_tty_close,
++ write: acm_tty_write,
++ write_room: acm_tty_write_room,
++ ioctl: acm_tty_ioctl,
++ throttle: acm_tty_throttle,
++ unthrottle: acm_tty_unthrottle,
++ chars_in_buffer: acm_tty_chars_in_buffer,
++ set_termios: acm_tty_set_termios,
++
++ refcount: &acm_tty_refcount,
++ table: acm_tty_table,
++ termios: acm_tty_termios,
++ termios_locked: acm_tty_termios_locked,
++};
++
++
++/* Transmit INTERRUPT ************************************************************************** */
++
++/**
++ * Generates a response urb on the notification (INTERRUPT) endpoint.
++ * Return a non-zero result code to STALL the transaction.
++ * CALLED from interrupt context.
++ */
++static int acm_send_int_notification(struct usb_function_instance *function, int bnotification, int data)
++{
++ struct acm_private *acm = &acm_private;
++ struct urb *urb = NULL;
++ struct cdc_notification_descriptor *notification;
++ unsigned long flags;
++ int rc;
++
++ //printk(KERN_INFO"%s: function: %p connected: %d DTR: %d\n", __FUNCTION__,
++ // function, acm->connected, acm->ctrlout & LINE_OUT_DTR);
++
++ local_irq_save(flags);
++ TRACE_MSG("entered");
++
++ do {
++ BREAK_IF(!function);
++ //BREAK_IF(!acm->connected || !acm->ctrlout & LINE_OUT_DTR);
++ BREAK_IF(!acm->connected);
++
++ //printk (KERN_INFO"%s: bnotification: %x data: %d int_urb: %p\n",
++ // __FUNCTION__, bnotification, data, acm->int_urb);
++
++ if (acm->int_urb) {
++ //uuu printk(KERN_INFO"%s: int_urb: %p\n", __FUNCTION__, acm->int_urb);
++ usbd_cancel_urb_irq(acm->int_urb);
++ acm->int_urb = NULL;
++ }
++
++ //printk(KERN_INFO"%s: AAA\n", __FUNCTION__);
++
++ //uuu printk(KERN_INFO"%s:\n", __FUNCTION__);
++ BREAK_IF(!(urb = usbd_alloc_urb (function, INT_IN,
++ sizeof(struct cdc_notification_descriptor), acm_urb_sent_int)));
++
++ //printk(KERN_INFO"%s: BBB\n", __FUNCTION__);
++
++ memset(urb->buffer, 0, urb->buffer_length);
++ urb->actual_length = sizeof(struct cdc_notification_descriptor);
++ urb->privdata = &acm_private;
++
++ // fill in notification structure
++ notification = (struct cdc_notification_descriptor *) urb->buffer;
++
++ notification->bmRequestType = USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
++ notification->bNotification = bnotification;
++
++ switch (bnotification) {
++ case CDC_NOTIFICATION_NETWORK_CONNECTION:
++ notification->wValue = data;
++ break;
++ case CDC_NOTIFICATION_SERIAL_STATE:
++ notification->wLength = cpu_to_le16(2);
++ *((unsigned short *)notification->data) = cpu_to_le16(data);
++ break;
++ }
++
++ acm->int_urb = urb;
++ //printk(KERN_INFO"%s: CCC\n", __FUNCTION__);
++ BREAK_IF(!(rc = usbd_send_urb (urb)));
++
++ //uuu printk(KERN_ERR"%s: usbd_send_urb failed err: %x\n", __FUNCTION__, rc);
++ acm->int_urb = urb;
++ urb->privdata = NULL;
++ usbd_dealloc_urb (urb);
++
++ } while(0);
++
++ TRACE_MSG1("urbID#%04x --> 0",urbID(urb));
++ local_irq_restore(flags);
++ //printk(KERN_INFO"%s: DDD\n", __FUNCTION__);
++ return 0;
++}
++
++/* Callback functions for TX urb completion (function chosen when urb is allocated) ***********/
++
++/* acm_urb_sent_bulk - called to indicate URB transmit finished
++ * @urb: pointer to struct urb
++ * @rc: result
++ */
++static int acm_urb_sent_bulk (struct urb *urb, int rc)
++{
++ struct acm_private *acm = &acm_private;
++ struct usb_function_instance *function;
++
++ acm_interrupts++;
++ TRACE_MSG2("entered urbID#%04x rc=%d",urbID(urb),rc);
++
++ if (!urb || !(function = urb->function_instance)) {
++ TRACE_MSG1("urbID#%04x --> -EINVAL",urbID(urb));
++ return(-EINVAL);
++ }
++ TRACE_MSG1("IN length=%d",urb->actual_length);
++
++ atomic_sub(urb->actual_length, &acm->queued_bytes);
++ atomic_dec(&acm->queued_urbs);
++ urb->privdata = NULL;
++ usbd_dealloc_urb (urb);
++ acm_schedule(&acm->wqueue);
++ TRACE_MSG1("urbID#%04x --> 0",urbID(urb));
++ return 0;
++}
++
++/* acm_urb_sent_int - called to indicate URB transmit finished
++ * @urb: pointer to struct urb
++ * @rc: result
++ */
++static int acm_urb_sent_int (struct urb *urb, int rc)
++{
++ struct acm_private *acm = &acm_private;
++ struct usb_function_instance *function;
++
++ acm_interrupts++;
++ TRACE_MSG2("entered urbID#%04x rc=%d",urbID(urb),rc);
++ //printk(KERN_INFO"%s: urb: %p function: %p rc: %d\n", __FUNCTION__, urb, urb->function_instance, rc);
++ if (!urb || !(function = urb->function_instance)) {
++ TRACE_MSG1("urbID#%04x --> -EINVAL",urbID(urb));
++ return(-EINVAL);
++ }
++ TRACE_MSG1("INT length=%d",urb->actual_length);
++
++ acm->int_urb = NULL;
++ usbd_dealloc_urb(urb);
++ TRACE_MSG1("urbID#%04x --> 0",urbID(urb));
++ return 0;
++}
++
++#if defined(CONFIG_USBD_ACM_DATALOG)
++/* acm_urb_sent_pst - called to indicate URB transmit finished
++ * @urb: pointer to struct urb
++ * @rc: result
++ */
++int acm_urb_sent_pst (struct urb *urb, int rc)
++{
++ struct acm_private *acm = &acm_private;
++ struct usb_function_instance *function;
++
++ acm_interrupts++;
++ TRACE_MSG2("entered urbID#%04x rc=%d",urbID(urb),rc);
++ //uuu printk(KERN_INFO"urb: %p function: %p rc: %d\n", urb, urb->function_instance, rc);
++ if (!urb || !(function = urb->function_instance)) {
++ TRACE_MSG1("urbID#%04x --> -EINVAL",urbID(urb));
++ return(-EINVAL);
++ }
++ TRACE_MSG1("PST length=%d",urb->actual_length);
++
++#if defined(PST_FD_AVAILABLE)
++ pst_urb_sent(urb, rc);
++#endif
++ urb->privdata = NULL;
++ usbd_dealloc_urb(urb);
++ TRACE_MSG1("urbID#%04x --> 0",urbID(urb));
++ return 0;
++}
++#endif
++
++/* USB Device Functions ************************************************************************ */
++
++/* acm_event_irq - process a device event
++ *
++ */
++void acm_event_irq (struct usb_function_instance *function, usb_device_event_t event, int data)
++{
++ struct acm_private *acm = &acm_private;
++ int i;
++
++ acm_interrupts++;
++ TRACE_MSG1("entered ev=%d",event);
++ switch (event) {
++
++#if defined(CONFIG_USBD_ACM_DATALOG)
++ case DEVICE_CREATE:
++#if defined(PST_FD_AVAILABLE)
++ if (0 != (ret = pst_dev_create(device)))
++ return;
++#endif
++ break;
++
++ case DEVICE_DESTROY:
++#if defined(PST_FD_AVAILABLE)
++ pst_dev_destroy();
++#endif
++ break;
++#endif
++
++ case DEVICE_CONFIGURED:
++ TRACE_MSG("CONFIGURED");
++ acm->connected = 1;
++ acm_schedule(&acm->wqueue);
++ for (i = 0; i < MAX_RECV_URBS; i++) {
++ struct urb *urb;
++ // printk(KERN_INFO"%s:\n", __FUNCTION__);
++ BREAK_IF(!(urb = usbd_alloc_urb(function, BULK_OUT,
++ usbd_endpoint_transferSize(function, BULK_OUT,usbd_high_speed(function)),
++ acm_recv_urb)));
++ if (usbd_start_recv(urb))
++ usbd_dealloc_urb(urb);
++ }
++ break;
++
++ case DEVICE_RESET:
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG("RESET");
++ BREAK_IF(!acm->connected);
++ acm->connected = 0;
++ acm->int_urb = NULL;
++ acm_schedule(&acm->hqueue);
++ // XXX flush
++ // Release any queued urbs
++ break;
++
++ default: break;
++ }
++ TRACE_MSG("exited");
++}
++
++static int acm_recv_urb (struct urb *urb, int rc)
++{
++ /* Return 0 if urb has been accepted,
++ return 1 and expect caller to deal with urb release otherwise. */
++ struct acm_private *acm = &acm_private;
++ struct tty_struct *tty = acm->tty;
++ struct urb *furb;
++
++ acm_interrupts++;
++ TRACE_MSG1("entered rc=%d",rc);
++ //printk(KERN_INFO"%s: urb: %p rc=%d\n", __FUNCTION__, urb, rc);
++ if (RECV_CANCELLED == rc) {
++ TRACE_MSG1("cancelled URB=%p",urb);
++ usbd_dealloc_urb(urb);
++ return(0);
++ }
++ if (RECV_OK != rc) {
++ // Shouldn't happen, but...
++ // Reject it.
++ TRACE_MSG1("rejected URB=%p",urb);
++ //printk(KERN_INFO"%s: rejecting URB %p rc=%d\n", __FUNCTION__, urb, rc);
++ return(1);
++ }
++ // Queue it for forwarding, then kick off forwarding routine.
++ acm->bytes_received += urb->actual_length;
++ acm->recv_ring[acm->rr_in_ndx] = urb;
++ acm->rr_in_ndx = (acm->rr_in_ndx + 1) % RECV_RING_SIZE;
++ if (urb == (furb = acm_frwd_recv_urbs(tty,acm))) {
++ // Couldn't restart urb, tell the caller to dispose of it.
++ TRACE_MSG1("caller to release URB=%p",urb);
++ //printk(KERN_INFO"%s: caller to release URB %p rc=%d\n", __FUNCTION__, urb, rc);
++ return(1);
++ }
++ if (NULL != furb) {
++ /* Couldn't restart some other urb, but we can't tell the caller
++ about it, so we need to dispose of it ourselves. This should
++ only happen if the bi layer is shutting down, so we let someone
++ else allocate the replacement if one is needed. */
++ TRACE_MSG1("releasing URB=%p",urb);
++ usbd_dealloc_urb(urb);
++ }
++ TRACE_MSG("--> 0");
++ return(0);
++}
++
++/* acm_line_coding_urb_received - callback for sent URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * Returns non-zero for failure.
++ */
++static int acm_line_coding_urb_received (struct urb *urb, int urb_rc)
++{
++ TRACE_MSG2("urbID#%04x rc=%d",urbID(urb),urb_rc);
++
++ RETURN_EINVAL_IF (RECV_OK != urb_rc);
++
++ return -EINVAL; // caller will de-allocate
++}
++
++/* acm_recv_setup_irq - called to indicate urb has been received
++ */
++int acm_recv_setup_irq (struct usb_device_request *request)
++{
++ struct acm_private *acm = &acm_private;
++ struct usb_function_instance *function = acm->function;
++
++ acm_interrupts++;
++ TRACE_SETUP(request);
++
++ // verify that this is a usb class request per cdc-acm specification or a vendor request.
++ if (!(request->bmRequestType & (USB_REQ_TYPE_CLASS | USB_REQ_TYPE_VENDOR))) {
++ TRACE_MSG("--> 0");
++ return(0);
++ }
++
++ // determine the request direction and process accordingly
++ switch (request->bmRequestType & (USB_REQ_DIRECTION_MASK | USB_REQ_TYPE_MASK)) {
++
++ case USB_REQ_HOST2DEVICE | USB_REQ_TYPE_CLASS:
++ switch (request->bRequest) {
++ case CDC_CLASS_REQUEST_SEND_ENCAPSULATED: break;
++ case CDC_CLASS_REQUEST_SET_COMM_FEATURE: break;
++ case CDC_CLASS_REQUEST_CLEAR_COMM_FEATURE: break;
++ case CDC_CLASS_REQUEST_SET_LINE_CODING:
++ {
++ struct urb *urb;
++ int len = le16_to_cpu(request->wLength);
++ TRACE_MSG1("SET_LINE_CODING wLength=%d",len);
++ if (len <= 0) {
++ TRACE_MSG("(len<=0)--> 0");
++ return(0);
++ }
++ // Set up an ep0 recv urb for the rest of it.
++ urb = usbd_alloc_urb_ep0(function, len, acm_line_coding_urb_received);
++ if (NULL == urb) {
++ TRACE_MSG("no mem for ep0 recv urb");
++ return(-EINVAL);
++ }
++ if (usbd_start_recv(urb)) {
++ TRACE_MSG("usbd_start_recv() failed");
++ usbd_dealloc_urb(urb); // de-alloc if error
++ TRACE_MSG("--> -EINVAL");
++ return(-EINVAL);
++ }
++ }
++ break;
++ case CDC_CLASS_REQUEST_SET_CONTROL_STATE:
++ {
++ struct acm_private *acm = &acm_private;
++ unsigned int prev_ctrlout = acm->ctrlout;
++ acm->ctrlout = le16_to_cpu(request->wValue);
++
++ TRACE_MSG1("set control state, tty=%p",acm->tty);
++ //uuu printk(KERN_INFO"%s: tty: %p clocal: %x ctrlout: %02x DTR: %x\n",
++ //uuu __FUNCTION__, acm->tty, acm->clocal, acm->ctrlout, acm->ctrlout & LINE_OUT_DTR);
++
++ // schedule writers or hangup IFF open
++ BREAK_IF(!acm->tty);
++ TRACE_MSG1("set control state, ctrlout#%04x",acm->ctrlout);
++ // make sure there really is a state change
++ if ((acm->ctrlout ^ prev_ctrlout) & LINE_OUT_DTR) {
++ TRACE_MSG1("DTR state changed -> %x",(acm->ctrlout&LINE_OUT_DTR));
++ //printk(KERN_INFO"%s: tty: %p DTR state changed -> %u\n",
++ // __FUNCTION__, acm->tty, (acm->ctrlout&LINE_OUT_DTR));
++ acm_schedule(((acm->ctrlout & LINE_OUT_DTR) ? &acm->wqueue : &acm->hqueue));
++ // wake up blocked opens
++ if (acm->open_wait_count > 0) {
++ wake_up_interruptible(&acm->open_wait);
++ }
++ } // end of state change operation
++
++ // send notification if we have DCD
++ TRACE_MSG1("checking DCD ctrlin#%04x",acm->ctrlin);
++ BREAK_IF(!(acm->ctrlin & (LINE_IN_DCD | LINE_IN_DSR)));
++ TRACE_MSG1("tty=%p sending (DCD|DSR) notification",acm->tty);
++ acm_send_int_notification(function, CDC_NOTIFICATION_SERIAL_STATE, acm->ctrlin);
++ }
++ break;
++
++ case CDC_CLASS_REQUEST_SEND_BREAK: break;
++ default: break;
++ }
++ TRACE_MSG("--> 0");
++ return 0;
++
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_CLASS:
++ switch (request->bRequest) {
++ case CDC_CLASS_REQUEST_GET_ENCAPSULATED: break;
++ case CDC_CLASS_REQUEST_GET_COMM_FEATURE: break;
++ case CDC_CLASS_REQUEST_GET_LINE_CODING:
++ {
++ struct urb *urb;
++ struct cdc_acm_line_coding *results;
++ int len = le16_to_cpu(request->wLength);
++ if (len != sizeof(struct cdc_acm_line_coding)) {
++ TRACE_MSG2("(len=%d!=sz=%d--> -EINVAL",len,sizeof(struct cdc_acm_line_coding));
++ return -EINVAL;
++ }
++
++ if (!(urb = usbd_alloc_urb_ep0(function, len, NULL))) {
++ TRACE_MSG("(nomem)--> -EINVAL");
++ return -EINVAL;
++ }
++ results = (struct cdc_acm_line_coding *)urb->buffer;
++ results->dwDTERate = cpu_to_le16(0x1c200); // 115200
++ results ->bDataBits = 0x08;
++ urb->actual_length = len;
++ TRACE_MSG1("sending line coding urb=%p",(u32)(void*)urb);
++ if (!usbd_send_urb(urb)) {
++ TRACE_MSG("--> 0");
++ return(0);
++ }
++ usbd_dealloc_urb(urb);
++ TRACE_MSG("(send failed)--> -EINVAL");
++ return -EINVAL;
++ }
++ default: break;
++ }
++ TRACE_MSG("--> 0");
++ return 0;
++
++ case USB_REQ_HOST2DEVICE | USB_REQ_TYPE_VENDOR: break;
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_VENDOR: break;
++#if defined(PST_FD_AVAILABLE)
++ ep0_process_vendor_request( urb );
++ TRACE_MSG("--> 0");
++ return 0;
++#endif
++
++ default: break;
++ }
++ TRACE_MSG("--> 0");
++ return 0;
++}
++
++
++static int acm_function_enable (struct usb_function_instance *function)
++{
++ struct acm_private *acm = &acm_private;
++ acm_interrupts++;
++ TRACE_MSG("entered");
++ MOD_INC_USE_COUNT;
++ acm->function = function;
++ acm->writesize = usbd_endpoint_wMaxPacketSize(function, BULK_OUT, 0) * 4; // QQSV
++ TRACE_MSG("-> 0");
++ return 0;
++}
++
++static void acm_function_disable (struct usb_function_instance *function)
++{
++ struct acm_private *acm = &acm_private;
++ acm_interrupts++;
++ TRACE_MSG("entered");
++ acm->writesize = 0;
++ acm->function = NULL;
++ MOD_DEC_USE_COUNT;
++ TRACE_MSG("exited");
++}
++
++
++static struct usb_function_operations function_ops = {
++ event_irq: acm_event_irq,
++ recv_setup_irq: acm_recv_setup_irq,
++ function_enable: acm_function_enable,
++ function_disable: acm_function_disable,
++};
++
++static struct usb_function_driver function_driver = {
++ name: "acm-CDC",
++ fops:&function_ops,
++ device_description:&acm_device_description,
++ bNumConfigurations:sizeof (acm_description) / sizeof (struct usb_configuration_description),
++ configuration_description:acm_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_ACM_BCDDEVICE),
++};
++
++#if defined(USE_TICKER)
++/* usb ticker ********************************************************************************** */
++
++#define retrytime 10
++
++int ticker_terminating;
++int ticker_timer_set;
++
++static DECLARE_MUTEX_LOCKED (ticker_sem_start);
++static DECLARE_MUTEX_LOCKED (ticker_sem_work);
++
++void ticker_tick (unsigned long data)
++{
++ ticker_timer_set = 0;
++ up (&ticker_sem_work);
++}
++
++void udc_ticker_poke (void)
++{
++ up (&ticker_sem_work);
++}
++
++int ticker_thread (void *data)
++{
++ struct timer_list ticker;
++ // detach
++ lock_kernel ();
++ exit_mm (current);
++ exit_files (current);
++ exit_fs (current);
++
++ // setsid equivalent, used at start of kernel thread, no error checks needed, or at least none made :).
++ current->leader = 1;
++ current->session = current->pgrp = current->pid;
++ current->tty = NULL;
++ current->tty_old_pgrp = 0;
++ sprintf (current->comm, "acm_fd");
++
++ // setup signal handler
++ current->exit_signal = SIGCHLD;
++ spin_lock (¤t->sigmask_lock);
++ flush_signals (current);
++ spin_unlock (¤t->sigmask_lock);
++
++ // run at a high priority, ahead of sync and friends
++ current->policy = SCHED_OTHER;
++ unlock_kernel ();
++
++ // setup timer
++ init_timer (&ticker);
++ ticker.data = 0;
++ ticker.function = ticker_tick;
++
++ // let startup continue
++ up (&ticker_sem_start);
++
++ // process loop
++ for (ticker_timer_set = ticker_terminating = 0; !ticker_terminating;) {
++
++ struct acm_private * acm = &acm_private;
++
++ if (!ticker_timer_set) {
++ mod_timer (&ticker, jiffies + HZ * retrytime);
++ }
++
++ // wait for someone to tell us to do something
++ down (&ticker_sem_work);
++
++ // sanity checks before proceeding
++ BREAK_IF(ticker_terminating);
++ CONTINUE_IF(!(function = acm->function));
++ CONTINUE_IF(USBD_OK != bus->status);
++
++ // do what we need to do
++ acm_send_int_notification(function, CDC_NOTIFICATION_SERIAL_STATE, acm->ctrlin);
++ }
++
++ // remove timer, let the process stopping us know we are done and return
++ del_timer (&ticker);
++ up (&ticker_sem_start);
++ return 0;
++}
++#endif
++
++
++/* USB Module init/exit ************************************************************************ */
++/*
++ * acm_modinit - module init
++ *
++ */
++static int acm_modinit (void)
++{
++ int i;
++ printk (KERN_INFO "Copyright (c) 2003-2004 sl@belcarra.com\n");
++
++ if (0 != acm_trace_init(ACM_TRACE_NAME)) {
++ printk(KERN_ERR"%s: ERROR tracing configured, but init failed.\n", __FUNCTION__);
++ return -EINVAL;
++ }
++ TRACE_MSG("entered");
++
++ if (vendor_id)
++ function_driver.idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ function_driver.idProduct = cpu_to_le16(product_id);
++ printk (KERN_INFO "%s: %s vendor_id: %04x product_id: %04x\n", __FUNCTION__,
++ __usbd_module_info, function_driver.idVendor, function_driver.idProduct);
++
++ // initialize private structure
++ acm_private.tty_driver = &acm_tty_driver;
++ acm_private.wqueue.routine = acm_wakeup_writers;
++ acm_private.wqueue.data = &acm_private;
++ acm_private.hqueue.routine = acm_hangup;
++ acm_private.hqueue.data = &acm_private;
++
++ init_waitqueue_head(&acm_private.open_wait);
++
++ for (i = 0; i < RECV_RING_SIZE; i++) {
++ acm_private.recv_ring[i] = NULL;
++ }
++ acm_private.rr_in_ndx = acm_private.rr_out_ndx = 0;
++
++ // register as tty driver
++ acm_tty_driver.init_termios = tty_std_termios;
++ acm_tty_driver.init_termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
++ acm_tty_driver.init_termios.c_lflag &= ~(ECHO | ICANON);
++ THROW_IF(tty_register_driver(&acm_tty_driver), error);
++
++ tty_register_devfs(&acm_tty_driver, 0, ACM_TTY_MINOR);
++ acm_private.tty_driver_registered++;
++
++ // register as usb function driver
++ THROW_IF (usbd_register_function (&function_driver), error);
++ acm_private.usb_driver_registered++;
++
++#if defined(USE_TICKER)
++ // kickoff_thread - start management thread
++ //ticker_terminating = 0;
++ //kernel_thread (&ticker_thread, NULL, 0);
++ //down (&ticker_sem_start);
++#endif
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: ERROR\n", __FUNCTION__);
++
++ if (acm_private.tty_driver_registered) {
++ tty_unregister_driver(&acm_tty_driver);
++ acm_private.tty_driver_registered = 0;
++ }
++ if (acm_private.usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ acm_private.usb_driver_registered = 0;
++ }
++ TRACE_MSG("--> -EINVAL");
++ return -EINVAL;
++ }
++ TRACE_MSG("--> 0");
++ return 0;
++}
++
++void acm_wait_task(struct tq_struct *queue)
++{
++ TRACE_MSG1("entered data=%p",queue->data);
++ RETURN_IF(!queue->data);
++ queue->data = NULL;
++ while (queue->sync) {
++ //uuu printk(KERN_INFO"%s: waiting for queue: %p\n", __FUNCTION__, queue);
++ TRACE_MSG1("waiting for queue: %p",queue);
++ schedule_timeout(HZ);
++ }
++ TRACE_MSG("exited");
++}
++
++/* acm_modexit - module cleanup
++ */
++static void acm_modexit (void)
++{
++ unsigned long flags;
++ struct urb *urb;
++ TRACE_MSG("entered");
++
++#if defined(USE_TICKER)
++ // killoff_thread - stop management thread
++ //if (!ticker_terminating) {
++ // ticker_terminating = 1;
++ // up (&ticker_sem_work);
++ // down (&ticker_sem_start);
++ //}
++#endif
++
++ // Wake up any pending opens after setting the exiting flag.
++ local_irq_save(flags);
++ acm_private.exiting = 1;
++ if (acm_private.open_wait_count > 0) {
++ wake_up_interruptible(&acm_private.open_wait);
++ }
++ local_irq_restore(flags);
++
++ // verify no tasks are running
++ acm_wait_task(&acm_private.wqueue);
++ acm_wait_task(&acm_private.hqueue);
++
++ // de-register as tty and usb drivers
++ if (acm_private.tty_driver_registered) {
++ tty_unregister_driver(&acm_tty_driver);
++ }
++ if (acm_private.usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ }
++
++ // Flush any urbs in the recv_ring.
++ while (acm_private.rr_in_ndx != acm_private.rr_out_ndx) {
++ // Remove and dealloc one URB from the receive ring
++ local_irq_save(flags);
++ urb = acm_private.recv_ring[acm_private.rr_out_ndx];
++ acm_private.recv_ring[acm_private.rr_out_ndx] = NULL;
++ acm_private.rr_out_ndx = (acm_private.rr_out_ndx + 1) % RECV_RING_SIZE;
++ local_irq_restore(flags);
++ // printk(KERN_INFO"%s: releasing URB %p\n", __FUNCTION__, urb);
++ usbd_dealloc_urb(urb);
++ }
++ acm_trace_exit(ACM_TRACE_NAME);
++}
++
++
++module_init (acm_modinit);
++module_exit (acm_modexit);
+diff -Nru a/drivers/usbd/acm_fd/trace.c b/drivers/usbd/acm_fd/trace.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/acm_fd/trace.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,530 @@
++/*
++ * usbd/acm_fd/trace.c
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2002 Lineo
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/version.h>
++
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/delay.h>
++
++#include <linux/proc_fs.h>
++#include <linux/vmalloc.h>
++
++#include <asm/atomic.h>
++#include <asm/io.h>
++
++#include <linux/proc_fs.h>
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,6)
++#define USE_ADD_DEL_TIMER_FOR_USBADDR_CHECK 1
++#include <linux/timer.h>
++#else
++#undef USE_ADD_DEL_TIMER_FOR_USBADDR_CHECK
++#include <linux/tqueue.h>
++#endif
++
++#include <linux/netdevice.h>
++#include <linux/pci.h>
++#include <linux/cache.h>
++
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++#include <asm/dma.h>
++#include <asm/mach/dma.h>
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/hardware.h>
++#include <asm/types.h>
++#endif
++
++#if defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++#include <asm/au1000.h>
++#include <asm/au1000_dma.h>
++#include <asm/mipsregs.h>
++#endif
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#include <asm/arch/timers.h>
++#include <asm/arch/hardware.h>
++#endif
++
++#if defined(CONFIG_ARCH_MX1ADS)
++#include "dbmx1_bi/dbmx1.h"
++#endif
++
++#include <asm/uaccess.h>
++#include <asm/io.h>
++#include <asm/pgtable.h>
++#include <asm/pgalloc.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <trace.h>
++
++
++int acm_trace_first;
++int acm_trace_last_read;
++int acm_trace_next;
++int acm_trace_total;
++acm_trace_t *acm_traces;
++
++extern int acm_interrupts;
++
++
++#if defined(CONFIG_USBD_ACM_TRACE) && defined(CONFIG_PROC_FS)
++
++acm_trace_t *ACM_TRACE_NEXT(char *fn, acm_trace_types_t acm_trace_type)
++{
++ acm_trace_t *p;
++ unsigned long flags;
++
++ // Get the next trace slot - this needs to be atomic.
++ local_irq_save (flags);
++ p = acm_traces + acm_trace_next;
++#if defined(TRACE_MAX_IS_2N)
++ acm_trace_next = (acm_trace_next + 1) & TRACE_MASK;
++ if (acm_trace_next == acm_trace_first) {
++ // We have wraparound, bump acm_trace_first
++ if (acm_trace_first == acm_trace_last_read) {
++ // We have to bump last read too.
++ acm_trace_last_read = (acm_trace_last_read + 1) & TRACE_MASK;
++ }
++ acm_trace_first = (acm_trace_first + 1) & TRACE_MASK;
++ }
++#else
++ if (TRACE_MAX <= ++acm_trace_next)
++ acm_trace_next = 0;
++
++ if (acm_trace_next == acm_trace_first) {
++ // We have wrap around, bump acm_trace_first
++ if (acm_trace_first == acm_trace_last_read) {
++ // We have to bump last read too.
++ if (TRACE_MAX <= ++acm_trace_last_read)
++ acm_trace_last_read = 0;
++ }
++ if (TRACE_MAX <= ++acm_trace_first)
++ acm_trace_first = 0;
++ }
++#endif
++ acm_trace_total++;
++ // End of next trace slot.
++ local_irq_restore (flags);
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ p->oscr = OSCR;
++#elif defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
++ p->cp0_count = __read_32bit_c0_register(CP0_COUNT);
++#else
++ p->cp0_count = read_c0_count();
++#endif
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ //p->jiffies = jiffies;
++ //p->tcnt0 = *(volatile u32 *)TCNT0;
++ p->tcnt1 = *(volatile u32 *)TCNT1;
++#else
++ p->jiffies = jiffies;
++#endif
++#if defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ //p->sofs = au_readl(USBD_FRAMENUM);
++#endif
++#if defined(CONFIG_ARCH_MX1ADS)
++ p->sofs = USBD_FRAME & 0x3ff;
++#endif
++
++ p->interrupts = acm_interrupts;
++ p->acm_trace_type = acm_trace_type;
++ p->function = fn;
++
++ //printk(KERN_INFO"first: %d next: %d interrupts: %d oscr: %d\n", acm_trace_first, acm_trace_next, acm_interrupts, p->oscr);
++
++ return p;
++}
++
++/* Proc Filesystem *************************************************************************** */
++
++/* *
++ * acm_trace_proc_read - implement proc file system read.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Standard proc file system read function.
++ */
++static ssize_t acm_trace_proc_read (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++ int oindex;
++ int previous;
++ unsigned long flags;
++
++ acm_trace_t px;
++ acm_trace_t ox;
++ acm_trace_t *o, *p;
++
++
++ MOD_INC_USE_COUNT;
++
++ /* Get the index of the entry to read and update last_read - this needs to be atomic. */
++ p = &px;
++ o = NULL;
++ oindex = index = (*pos)++;
++ local_irq_save (flags);
++
++#if defined(TRACE_MAX_IS_2N)
++ index = (acm_trace_first + index) & TRACE_MASK;
++#else
++ index += acm_trace_first;
++ if (index >= TRACE_MAX) {
++ index -= TRACE_MAX;
++ }
++#endif
++ // Are we at the end of the data?
++ if (((acm_trace_first < acm_trace_next) &&
++ (index >= acm_trace_first) && (index < acm_trace_next)) ||
++ ((acm_trace_first > acm_trace_next) &&
++ ((index < acm_trace_next) || (index >= acm_trace_first)))) {
++ // Nope, there's data to show.
++ memcpy(p,(acm_traces+index),sizeof(acm_trace_t));
++ // Is there a previous event?
++ previous = (index) ? (index - 1) : (TRACE_MAX - 1);
++ if (previous != acm_trace_next && acm_trace_total > 1) {
++ // There is a valid previous event.
++ o = &ox;
++ memcpy(o,(acm_traces+previous),sizeof(acm_trace_t));
++ }
++ acm_trace_last_read = index;
++ } else {
++ index = -1;
++ }
++ local_irq_restore (flags);
++ if (index < 0) {
++ // End of data.
++ return(0);
++ }
++
++ // get a page, max 4095 bytes of data...
++ if (!(page = get_free_page (GFP_KERNEL))) {
++ MOD_DEC_USE_COUNT;
++ return -ENOMEM;
++ }
++
++ len = 0;
++
++ if (oindex == 0) {
++#if defined(CONFIG_ARCH_SAMSUNG)
++ len += sprintf ((char *) page + len, " Index Ints Ticks [%d]\n", CONFIG_USBD_SMDK2500_BCLOCK );
++#else
++ len += sprintf ((char *) page + len, " Index Ints Ticks\n");
++#endif
++ }
++
++ //printk(KERN_INFO"first: %d next: %d index: %d %d prev: %d\n", acm_trace_first, acm_trace_next, oindex, index, previous);
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA) || defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ u32 ticks = 0;
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ u32 ticks = 0;
++#else
++ u64 jifs = 0;
++#endif
++ unsigned char *cp;
++ unsigned int *ip;
++ int skip = 0;
++
++ /* If there is a previous trace event, we want to calculate how many
++ ticks have elapsed siince it happened. Unfortunately, determining
++ if there _is_ a previous event isn't obvious, since we have to watch
++ out for startup and wraparound. */
++ if (o != NULL) {
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ /*
++ * oscr is 3.6864 Mhz free running counter,
++ *
++ * 1/3.6864 = .2712
++ * 60/221 = .2714
++ *
++ */
++ if (o->oscr) {
++ ticks = (p->oscr > o->oscr) ? (p->oscr - o->oscr) : (o->oscr - p->oscr) ;
++ ticks = (ticks * 60) / 221;
++ }
++
++#elif defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ /*
++ * cp0_count is incrementing timer at system clock
++ */
++ if (o->cp0_count) {
++ ticks = (p->cp0_count > o->cp0_count) ?
++ (p->cp0_count - o->cp0_count) : (o->cp0_count - p->cp0_count) ;
++ ticks = ticks / CONFIG_USBD_AU1X00_SCLOCK;
++ }
++
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ /*
++ * tcnt1 is a count-down timer running at the system bus clock
++ * The divisor must be set as a configuration value, typically 66 or 133.
++ */
++ if (o->tcnt1) {
++ ticks = (p->tcnt1 < o->tcnt1) ? (o->tcnt1 - p->tcnt1) : (p->tcnt1 - o->tcnt1) ;
++ ticks /= CONFIG_USBD_SMDK2500_BCLOCK;
++ }
++#else
++ if (o->jiffies) {
++ jifs = p->jiffies - acm_traces[previous].jiffies;
++ }
++#endif
++
++ if (o->interrupts != p->interrupts) {
++ skip++;
++ }
++ }
++
++ //printk(KERN_INFO"index: %d interrupts: %d\n", index, p->interrupts);
++ len += sprintf ((char *) page + len, "%s%6d %8d ", skip?"\n":"", index, p->interrupts);
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA) || defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ if (ticks > 1024*1024) {
++ len += sprintf ((char *) page + len, "%8dM ", ticks>>20);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%8d ", ticks);
++ }
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ //len += sprintf ((char *) page + len, "%8u ", p->jiffies);
++ //len += sprintf ((char *) page + len, "%8u ", p->tcnt0);
++ len += sprintf ((char *) page + len, "%8u ", p->tcnt1);
++ if (ticks > 1024*1024) {
++ len += sprintf ((char *) page + len, "%8dM ", ticks>>20);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%8d ", ticks);
++ }
++#else
++ if (jifs > 1024) {
++ len += sprintf ((char *) page + len, "%4dK ", (int)jifs>>10);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%4d ", (int)jifs);
++ }
++#endif
++#if defined(CONFIG_ARCH_MX1ADS)
++ len += sprintf ((char *) page + len, "%6d ", (int)p->sofs);
++#endif
++
++ switch (p->acm_trace_type) {
++ case acm_trace_msg_n:
++ len += sprintf ((char *) page + len, " -- %s: ",p->function);
++ len += sprintf ((char *) page + len, p->trace.msg.msg);
++ break;
++
++ case acm_trace_msg32_n:
++ len += sprintf ((char *) page + len, " -- %s: ",p->function);
++ len += sprintf ((char *) page + len, p->trace.msg32.msg, p->trace.msg32.val);
++ break;
++
++ case acm_trace_msg16_n:
++ len += sprintf ((char *) page + len, " -- %s: ",p->function);
++ len += sprintf ((char *) page + len, p->trace.msg16.msg, p->trace.msg16.val0, p->trace.msg16.val1);
++ break;
++
++ case acm_trace_msg8_n:
++ len += sprintf ((char *) page + len, " -- %s: ",p->function);
++ len += sprintf ((char *) page + len, p->trace.msg8.msg,
++ p->trace.msg8.val0, p->trace.msg8.val1, p->trace.msg8.val2, p->trace.msg8.val3);
++ break;
++
++ case acm_trace_setup_n:
++ cp = (unsigned char *)&p->trace.setup;
++ len += sprintf ((char *) page + len,
++ " -- %s: request [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ p->function, cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++ break;
++ }
++ len += sprintf ((char *) page + len, "\n");
++
++ // len == 0 is valid, it just means we've reached the end of the data.
++ if (len > count) {
++ len = -EINVAL;
++ }
++ else if (len > 0 && copy_to_user (buf, (char *) page, len)) {
++ len = -EFAULT;
++ }
++ free_page (page);
++ MOD_DEC_USE_COUNT;
++ return len;
++}
++
++/* *
++ * acm_trace_proc_write - implement proc file system write.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Proc file system write function.
++ */
++static ssize_t acm_trace_proc_write (struct file *file, const char *buf, size_t count, loff_t * pos)
++{
++#define MAX_TRACE_CMD_LEN 64
++ char command[MAX_TRACE_CMD_LEN+1];
++ size_t n = count;
++ size_t l;
++ char c;
++
++ if (n > 0) {
++ l = MIN(n,MAX_TRACE_CMD_LEN);
++ if (copy_from_user (command, buf, l)) {
++ count = -EFAULT;
++ } else {
++ // flush remainder, if any
++ n -= l;
++ while (n > 0) {
++ // Not too efficient, but it shouldn't matter
++ if (copy_from_user (&c, buf + (count - n), 1)) {
++ count = -EFAULT;
++ break;
++ }
++ n -= 1;
++ }
++ // Terminate command[]
++ if (l > 0 && command[l-1] == '\n') {
++ l -= 1;
++ }
++ command[l] = 0;
++ }
++ }
++
++ if (0 >= count) {
++ printk(KERN_INFO"%s: count <= 0 %d\n", __FUNCTION__, count);
++ return count;
++ }
++
++ if (!strncmp("flush", command, 5)) {
++ /* Move pointers so that next read continues from last read point,
++ instead of all available messages - this needs to be atomic. */
++ unsigned long flags;
++
++ local_irq_save (flags);
++#if defined(TRACE_MAX_IS_2N)
++ acm_trace_first = (acm_trace_last_read + 1) & TRACE_MASK;
++#else
++ if (TRACE_MAX <= (acm_trace_first = acm_trace_last_read + 1)) {
++ acm_trace_first = 0;
++ }
++#endif
++ local_irq_restore (flags);
++ }
++
++ return count;
++}
++
++static struct file_operations acm_trace_proc_operations_functions = {
++ read:acm_trace_proc_read,
++ write:acm_trace_proc_write,
++};
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#endif
++
++/**
++ * acm_trace_init
++ *
++ * Return non-zero if not successful.
++ */
++int acm_trace_init (char *name)
++{
++ printk(KERN_INFO"%s: creating /proc/%s with %u entries\n", __FUNCTION__,name,TRACE_MAX);
++ if (!(acm_traces = vmalloc(sizeof(acm_trace_t) * TRACE_MAX))) {
++ printk(KERN_ERR"%s: malloc failed %p %d\n", __FUNCTION__, acm_traces, sizeof(acm_trace_t) * TRACE_MAX);
++ return -EINVAL;
++ }
++ memset(acm_traces, 0, sizeof(acm_trace_t) * TRACE_MAX);
++ acm_trace_last_read = TRACE_MAX - 1;
++
++ {
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry (name, 0, 0)) == NULL) {
++ printk(KERN_INFO"%s PROC FS failed\n",name);
++ }
++ else {
++ p->proc_fops = &acm_trace_proc_operations_functions;
++ }
++ }
++#if defined(CONFIG_ARCH_SAMSUNG)
++ *(volatile u32 *)TMOD |= 0x3 << 3;
++#endif
++ printk(KERN_INFO"%s: OK\n", __FUNCTION__);
++ return 0;
++}
++
++/**
++ * acm_trace_exit - remove procfs entry, free trace data space.
++ */
++void acm_trace_exit (char *name)
++{
++ {
++ unsigned long flags;
++ local_irq_save (flags);
++ remove_proc_entry (name, NULL);
++ if (acm_traces) {
++ acm_trace_t *p = acm_traces;
++ acm_traces = NULL;
++ vfree(p);
++ }
++ local_irq_restore (flags);
++ }
++}
++
++
++#else
++int acm_trace_init (char *name)
++{
++ return 0;
++}
++
++void acm_trace_exit (char *name)
++{
++ return;
++}
++#endif
++
++/* End of FILE */
++
+diff -Nru a/drivers/usbd/acm_fd/trace.h b/drivers/usbd/acm_fd/trace.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/acm_fd/trace.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,268 @@
++/*
++ * usbd/acm_fd/trace.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2002 Lineo
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#ifndef CONFIG_USBD_SMDK2500_BCLOCK
++#define CONFIG_USBD_SMDK2500_BCLOCK 66
++#endif
++#endif
++
++/* Fast Trace Utility
++ This set of definitions and code is meant to provide a _fast_ debugging facility
++ (much faster than printk) so that time critical code can be debugged by looking
++ at a trace of events provided by reading a file in the procfs without affecting
++ the timing of events in the critical code.
++
++ The mechanism used it to allocate a (large) ring buffer of relatively small structures
++ that include location and high-res timestamp info, and up to 8 bytes of optional
++ data. Values are stored and timestamps are taken as the critical code runs, but
++ data formatting and display are done during the procfs read, when more time is
++ available :).
++
++ Note that there is usually some machine dependent code involved in getting the
++ high-res timestamp, and there may be other bits used just to keep the overall
++ time impact as low as possible.
++
++ varargs style macros were avoided because there seems to be no way to avoid
++ a run-time check on the number of arguments if they are used, and the time penalty
++ doesn't seem to be worth the gain in utility.
++ */
++
++typedef enum acm_trace_types {
++ acm_trace_setup_n, acm_trace_msg_n, acm_trace_msg32_n, acm_trace_msg16_n, acm_trace_msg8_n
++} acm_trace_types_t;
++
++typedef struct acm_trace_msg {
++ char *msg;
++} acm_trace_msg_t;
++
++typedef struct acm_trace_msg32 {
++ u32 val;
++ char *msg;
++} acm_trace_msg32_t;
++
++typedef struct acm_trace_msg16 {
++ u16 val0;
++ u16 val1;
++ char *msg;
++} acm_trace_msg16_t;
++
++typedef struct acm_trace_msg8 {
++ u8 val0;
++ u8 val1;
++ u8 val2;
++ u8 val3;
++ char *msg;
++} acm_trace_msg8_t;
++
++
++typedef struct trace {
++ acm_trace_types_t acm_trace_type;
++ char *function;
++ u32 interrupts;
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ u32 oscr;
++#elif defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ u32 cp0_count;
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ //u32 tcnt0;
++ u32 tcnt1;
++ //u64 jiffies;
++#else
++ u64 jiffies;
++#endif
++#if defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100) || defined(CONFIG_ARCH_MX1ADS)
++ u64 sofs;
++#endif
++ union {
++ acm_trace_msg_t msg;
++ acm_trace_msg8_t msg8;
++ acm_trace_msg16_t msg16;
++ acm_trace_msg32_t msg32;
++
++ struct usb_device_request setup;
++
++ } trace;
++
++} acm_trace_t;
++
++#define TRACE_MAX_IS_2N 1
++#if defined(TRACE_MAX_IS_2N)
++#define TRACE_MAX 0x00008000
++#define TRACE_MASK 0x00007FFF
++#else
++#define TRACE_MAX 30000
++#endif
++
++extern int acm_trace_first;
++extern int acm_trace_last_read;
++extern int acm_trace_next;
++
++extern acm_trace_t *acm_traces;
++
++#ifdef CONFIG_USBD_ACM_TRACE
++
++acm_trace_t *ACM_TRACE_NEXT(char *fn, acm_trace_types_t acm_trace_type);
++
++#if 0
++static __inline__ acm_trace_t *ACM_TRACE_NEXT(char *fn, acm_trace_types_t acm_trace_type)
++{
++ acm_trace_t *p;
++ unsigned long flags;
++
++ // Get the next trace slot - this needs to be atomic.
++ local_irq_save (flags);
++ p = acm_traces + acm_trace_next;
++#if defined(TRACE_MAX_IS_2N)
++ acm_trace_next = (acm_trace_next + 1) & TRACE_MASK;
++ if (acm_trace_next == acm_trace_first) {
++ // We have wraparound, bump acm_trace_first
++ if (acm_trace_first == acm_trace_last_read) {
++ // We have to bump last read too.
++ acm_trace_last_read = (acm_trace_last_read + 1) & TRACE_MASK;
++ }
++ acm_trace_first = (acm_trace_first + 1) & TRACE_MASK;
++ }
++#else
++ if (TRACE_MAX <= ++acm_trace_next)
++ acm_trace_next = 0;
++
++ if (acm_trace_next == acm_trace_first) {
++ // We have wrap around, bump acm_trace_first
++ if (acm_trace_first == acm_trace_last_read) {
++ // We have to bump last read too.
++ if (TRACE_MAX <= ++acm_trace_last_read)
++ acm_trace_last_read = 0;
++ }
++ if (TRACE_MAX <= ++acm_trace_first)
++ acm_trace_first = 0;
++ }
++#endif
++ // End of next trace slot.
++ local_irq_restore (flags);
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ p->oscr = OSCR;
++#elif defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ //p->cp0_count = __read_32bit_c0_register(CP0_COUNT);
++ p->cp0_count = read_c0_count();
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ //p->jiffies = jiffies;
++ //p->tcnt0 = *(volatile u32 *)TCNT0;
++ p->tcnt1 = *(volatile u32 *)TCNT1;
++#else
++ p->jiffies = jiffies;
++#endif
++#if defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
++ //p->sofs = au_readl(USBD_FRAMENUM);
++#endif
++
++ p->interrupts = udc_interrupts;
++ p->acm_trace_type = acm_trace_type;
++ p->function = fn;
++
++ acm_trace_next++;
++ acm_trace_next = (acm_trace_next == TRACE_MAX) ? 0 : acm_trace_next;
++
++ if (acm_trace_next == acm_trace_first) {
++ acm_trace_first++;
++ acm_trace_first = (acm_trace_first == TRACE_MAX) ? 0 : acm_trace_first;
++ }
++ //printk(KERN_INFO"first: %d next: %d interrupts: %d\n", acm_trace_first, acm_trace_next, udc_interrupts);
++
++ return p;
++}
++#endif
++
++static __inline__ void acm_trace_setup(char *fn, struct usb_device_request *setup)
++{
++ if (acm_traces) {
++ acm_trace_t *p = ACM_TRACE_NEXT(fn,acm_trace_setup_n);
++ memcpy(&p->trace.setup, setup, sizeof(struct usb_device_request));
++ }
++}
++#define TRACE_SETUP(setup) acm_trace_setup(__FUNCTION__,setup)
++
++static __inline__ void acm_trace_msg(char *fn, char *msg)
++{
++ if (acm_traces) {
++ acm_trace_t *p = ACM_TRACE_NEXT(fn,acm_trace_msg_n);
++ p->trace.msg.msg = msg;
++ }
++}
++#define TRACE_MSG(msg) acm_trace_msg(__FUNCTION__,msg)
++
++
++static __inline__ void acm_trace_msg_1xU32(char *fn, char *fmt, u32 val)
++{
++ if (acm_traces) {
++ acm_trace_t *p = ACM_TRACE_NEXT(fn,acm_trace_msg32_n);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = fmt;
++ }
++}
++#define TRACE_MSG1(fmt,val) acm_trace_msg_1xU32(__FUNCTION__,fmt,(u32)val)
++
++static __inline__ void acm_trace_msg_2xU16(char *fn, char *fmt, u16 val0, u16 val1)
++{
++ if (acm_traces) {
++ acm_trace_t *p = ACM_TRACE_NEXT(fn,acm_trace_msg16_n);
++ p->trace.msg16.val0 = val0;
++ p->trace.msg16.val1 = val1;
++ p->trace.msg16.msg = fmt;
++ }
++}
++#define TRACE_MSG2(fmt,val0,val1) acm_trace_msg_2xU16(__FUNCTION__,fmt,(u16)val0,(u16)val1)
++
++static __inline__ void acm_trace_msg_4xU8(char *fn, char *fmt, u8 val0, u8 val1, u8 val2, u8 val3)
++{
++ if (acm_traces) {
++ acm_trace_t *p = ACM_TRACE_NEXT(fn,acm_trace_msg8_n);
++ p->trace.msg8.val0 = val0;
++ p->trace.msg8.val1 = val1;
++ p->trace.msg8.val2 = val2;
++ p->trace.msg8.val3 = val3;
++ p->trace.msg8.msg = fmt;
++ }
++}
++#define TRACE_MSG4(fmt,val0,val1,val2,val3) acm_trace_msg_4xU8(__FUNCTION__,fmt,(u8)val0,(u8)val1,(u8)val2,(u8)val3)
++
++#else
++
++#define TRACE_SETUP(setup)
++#define TRACE_MSG(msg)
++#define TRACE_MSG1(fmt,val)
++#define TRACE_MSG2(fmt,val0,val1)
++#define TRACE_MSG4(fmt,val0,val1,val2,val3)
++
++#endif
++
++int acm_trace_init (char *str);
++void acm_trace_exit (char *str);
++
+diff -Nru a/drivers/usbd/au1x00_bi/Config.in b/drivers/usbd/au1x00_bi/Config.in
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/au1x00_bi/Config.in Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,27 @@
++
++# USB device configuration from the device viewpoint (e.g. Linux running inside a USB device, not as host)
++#
++# Copyright (c) 2002-2003 Belcarra
++#
++
++#
++# CONFIG_SOC_AU1X00 and/or CONFIG_MIPS_AU1X00 are the new and preferred tags (as of 2.4.20)
++#
++# CONFIG_MIPS_AU1000, CONFIG_MIPS_AU1100, CONFIG_MIPS_AU1500 are deprecated (prior to 2.4.20)
++#
++
++if [ "$CONFIG_SOC_AU1X00" = "y" -o "$CONFIG_MIPS_AU1X00" = "y" -o "$CONFIG_CPU_AU1X00" = "y" -o "$CONFIG_MIPS_AU1500" = "y" -o "$CONFIG_MIPS_AU1100" = "y" -o "$CONFIG_MIPS_AU1000" = "y" ]
++then
++ mainmenu_option next_comment
++
++ comment 'AMD AU1X000 Bus Interface'
++
++ dep_tristate ' AU1X00 (AMD/Alchemy) support' CONFIG_USBD_AU1X00_BUS $CONFIG_USBD
++ if [ "$CONFIG_USBD_AU1X00_BUS" = "m" -o "$CONFIG_USBD_AU1X00_BUS" = "y" ]; then
++ int ' AU1X00 System Clock' CONFIG_USBD_AU1X00_SCLOCK 400
++ fi
++ define_bool CONFIG_AU1000_USB_DEVICE y
++ define_bool CONFIG_AU1X00_USB_DEVICE y
++
++ endmenu
++fi
+diff -Nru a/drivers/usbd/au1x00_bi/Makefile b/drivers/usbd/au1x00_bi/Makefile
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/au1x00_bi/Makefile Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,88 @@
++#
++# Makefile for the kernel USBD (device not host) drivers.
++#
++# Copyright (c) 2002 Belcarra
++
++# Subdirs.
++# This is a bit complex, because some subdirs are for
++# proprietary code, and are simply not present in a
++# general distribution.
++
++# The all-CAPS *_DIRS get nuked in the new versions
++# of Rules.make, so use only the subdir-* methods.
++subdir-y :=
++subdir-m :=
++subdir-n :=
++subdir- :=
++
++# The target object and module list name.
++
++O_TARGET := au1x00_bi.o
++
++# Objects that export symbols.
++
++export-objs :=
++
++# Multipart objects.
++
++au1x00_bi-objs := au1x00.o usbd-bi.o trace.o
++
++# Optional parts of multipart objects.
++
++# Object file lists.
++
++#obj-y := usbd-bi.o
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_USBD_AU1X00_BUS) += au1x00_bi.o
++
++# Object files in subdirectories
++
++
++# Extract lists of the multi-part drivers.
++# The 'int-*' lists are the intermediate files used to build the multi's.
++
++multi-y := $(filter $(list-multi), $(obj-y))
++multi-m := $(filter $(list-multi), $(obj-m))
++int-y := $(sort $(foreach m, $(multi-y), $($(basename $(m))-objs)))
++int-m := $(sort $(foreach m, $(multi-m), $($(basename $(m))-objs)))
++
++# Files that are both resident and modular: remove from modular.
++
++obj-m := $(filter-out $(obj-y), $(obj-m))
++int-m := $(filter-out $(int-y), $(int-m))
++
++# Translate to Rules.make lists.
++
++O_OBJS := $(filter-out $(export-objs), $(obj-y))
++OX_OBJS := $(filter $(export-objs), $(obj-y))
++M_OBJS := $(sort $(filter-out $(export-objs), $(obj-m)))
++MX_OBJS := $(sort $(filter $(export-objs), $(obj-m)))
++MI_OBJS := $(sort $(filter-out $(export-objs), $(int-m)))
++MIX_OBJS := $(sort $(filter $(export-objs), $(int-m)))
++
++# The global Rules.make.
++
++include $(TOPDIR)/Rules.make
++USBD=$(TOPDIR)/drivers/usbd
++BI_DIR=$(USBD)/au1x00_bi
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format -I$(USBD) -I$(BI_DIR)
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format -I$(USBD) -I$(BI_DIR)
++
++vpath %.c $(USBD)
++
++# Link rules for multi-part drivers.
++
++au1x00_bi.o: $(au1x00_bi-objs)
++ $(LD) -r -o $@ $(au1x00_bi-objs)
++
++# dependencies:
++
++# local
++
++
+diff -Nru a/drivers/usbd/au1x00_bi/au1x00.c b/drivers/usbd/au1x00_bi/au1x00.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/au1x00_bi/au1x00.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,1268 @@
++/*
++ * usbd/au1x00_bi/au1x00.c -- USB Device Controller driver.
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2002 Lineo
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ * This program is free software; you can redistribute it and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
++ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ * See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along with this program; if
++ * not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ * Notes
++ *
++ * 1. EP0 - packetsize of 8 does not work, this means that PIO cannot be used for IN (transmit).
++ * DMA must be used. Only 16, 32 and 64 are usable.
++ *
++ * Update: even though we couldn't program the endpoint size to 8, we just set it to 8 in the
++ * device descriptor and things work ok. This works and we don't need or use DMA for either
++ * direction for EP0.
++ *
++ * 2. For each BULK transfer the first N packets must be sent with the full packetsize and the
++ * last must be sent as a short packet. The packetsize must be set before enabling the DMA.
++ *
++ * 3. For IN endpoints an interrupt will be generated for EVERY IN packet including ones that
++ * will be NAK'd. To reduce overhead the interrupt should only be enabled when there is data
++ * being sent and we need to know when it has been sent.
++ *
++ * Update: for new silicon this is not true, the UDC will interrupt less often and will NAK
++ * until the interrupt is cleared.
++ *
++ * 4. The AU1x00 auto-acks many setup commands and is very sensitive to latency of the irq
++ * handler processing the interrupt and clearing the ep0 fifo. Like the pxa we need to spool the
++ * requests and process later when we receive a request for data. There is a special test in
++ * the bulk data receive handler to check if there are spooled requests to process.
++ *
++ * Update: this has been mostly mitigated by reducing all upper layer processing in recv_setup,
++ * event_irq etc so that they complete in less than a milli-second. This simplifies things and
++ * we can now pass UUT tests.
++ *
++ * 5. There is a time sensitive problem in au_in_epn(). Without a udelay(8) sending large
++ * packets will eventually stall interrupts.
++ *
++ * Update: this is not required for new silicon.
++ *
++ * 6. When receiving data (Bulk OUT) the UDC will not start NAKing until and unless the receive
++ * FIFO is full. This means that there is no reliable way to determine the end of one packet and
++ * the beginning of the next if there is any undue latency in handling the interrupt for the
++ * first packet.
++ *
++ * The Belcarra Windows and Macintosh network class drivers have an option that can be used
++ * to pad all outgoing packets to a multiple of 8 bytes. This helps eliminate this problem.
++ *
++ * Update: this is not a problem with new silicon, it NAK's until the interrupt is cleared.
++ *
++ * 8. The original AU1x00 UDC generated an interrupt for EVERY IN packet. If we do not have
++ * any data we need to disable the interrupt for the endpoint to eliminate the overhead
++ * for processing them. The interrupt must be re-enabled when DMA is finished and we
++ * actually want to know that the endpoint has finished.
++ *
++ * Leaving the interrupt enabled also interfers with the DMA process. It is not apparant
++ * why.
++ *
++ * Update: This has been fixed on the new silicon but it doesn't hurt to continue to do this.
++ *
++ * 9. The DMA functions replace the equivalent routines in au1100_dma.h except that they pass
++ * the actual struct dma_chan pointer instead of the channel number. The bounds checking and
++ * table lookup to derive this information amounts to a substantial increase in code size and
++ * latency which can simply be avoided by using the structure address directly and/or doing the
++ * equivalent i/o directly.
++ */
++
++
++#include <udc.h>
++#include "au1x00.h"
++
++#include <asm/io.h>
++#include <asm/au1000.h>
++#include <asm/au1000_dma.h>
++#include <asm/mipsregs.h>
++
++
++#ifdef CONFIG_MIPS_FREEHAND
++#include <linux/i2c.h>
++#include <linux/sensors.h> /* for reading serial number */
++#endif
++
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_DESCRIPTION ("USB Device AU1x00 Bus Interface");
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("GPL");
++#endif
++USBD_MODULE_INFO ("au1x00_bi 2.0-beta");
++const char *usbd_bi_module_info(void)
++{ return __usbd_module_info; }
++
++#undef CHECK_LATENCY
++#undef RECORD_LATENCY
++#undef MAX_INTR_LOOP_STATS 10
++#if defined(MAX_INTR_LOOP_STATS)
++static u32 interrupt_loop_stats[MAX_INTR_LOOP_STATS+1];
++#endif
++#ifdef RECORD_LATENCY
++#define CP0_COUNTS 50
++u32 cp0_counts[CP0_COUNTS];
++u32 cp0_record;
++#endif
++u32 cp0_count;
++unsigned int udc_interrupts;
++unsigned int udc_saw_bus_activity;
++int au_halt_dma_expired;
++u32 au1x00_new_silicon;
++u32 au1x00_inten;
++static int udc_connected_status;
++
++__u8 au1x00_config_bulk[25] = {
++ 0x04, (USB_ENDPOINT_CONTROL << 4) | (EP0_PACKETSIZE & 0x380) >> 7, // 1
++ (EP0_PACKETSIZE & 0x7F) << 1, 0x00, 0x00,
++ 0x24, (USB_ENDPOINT_BULK << 4) | USB_DIR_IN | (MAX_EPN_PACKET_SIZE & 0x380) >> 7, // 6
++ (MAX_EPN_PACKET_SIZE & 0x7F) << 1, 0x00, 0x02,
++ 0x34, (USB_ENDPOINT_BULK << 4) | USB_DIR_IN | (MAX_EPN_PACKET_SIZE & 0x380) >> 7, // 11
++ (MAX_EPN_PACKET_SIZE & 0x7F) << 1, 0x00, 0x03,
++ 0x44, (USB_ENDPOINT_BULK << 4) | USB_DIR_OUT | (MAX_EPN_PACKET_SIZE & 0x380) >> 7, // 16
++ (MAX_EPN_PACKET_SIZE & 0x7F) << 1, 0x00, 0x04,
++ 0x54, (USB_ENDPOINT_BULK << 4) | USB_DIR_OUT | (MAX_EPN_PACKET_SIZE & 0x380) >> 7, // 21
++ (MAX_EPN_PACKET_SIZE & 0x7F) << 1, 0x00, 0x05,
++};
++
++/* ********************************************************************************************* */
++/* Note - The endpoints names are confusing. To simplify mapping of the interrupt request lines
++ * we use a numbering of the physical endpoints of 0-5, which also matches the fifo numbering
++ * (see the config block).
++ *
++ * Physical FIFO Name Direction Logical
++ * 0 0 EP0 OUT 0
++ * 1 1 EP0 IN 0
++ * 2 2 EP1 IN 81
++ * 3 3 EP2 IN 82
++ * 4 4 EP3 OUT 3
++ * 5 5 EP4 OUT 4
++ *
++ * The ep_regs array maps a physical endpoint number to the registers required to access the udc
++ * for that endpoint. Note that ep0 is always accessed via 0. The epl2p array maps the logical
++ * addresses back to the physical number. The epp2l array maps the physical number to the
++ * logical endpoint address
++ */
++struct ep_regs ep_regs[6] = {
++ { rd: USBD_EP0RD, rds: USBD_EP0RDSTAT, /*rx_id: DMA_ID_USBDEV_EP0_RX,*/ cs: USBD_EP0CS, rx_str: "EP0 OUT RD",
++ wr: USBD_EP0WR, wrs: USBD_EP0WRSTAT, tx_id: DMA_ID_USBDEV_EP0_TX, tx_str: "EP0 IN WR",},
++ { rds: 0, wrs: 0, indma: -1, outdma: -1, },
++ { wr: NUSBD_EP1WR, wrs: NUSBD_EP1WRSTAT, tx_id: NDMA_ID_USBDEV_EP1_TX, cs: NUSBD_EP1CS, tx_str: "EP1 IN WR",},
++ { wr: NUSBD_EP2WR, wrs: NUSBD_EP2WRSTAT, tx_id: NDMA_ID_USBDEV_EP2_TX, cs: NUSBD_EP2CS, tx_str: "EP2 IN WR",},
++
++ { rd: NUSBD_EP3RD, rds: NUSBD_EP3RDSTAT, rx_id: NDMA_ID_USBDEV_EP3_RX, cs: NUSBD_EP3CS, rx_str: "EP3 OUT RD",},
++ { rd: NUSBD_EP4RD, rds: NUSBD_EP4RDSTAT, rx_id: NDMA_ID_USBDEV_EP4_RX, cs: NUSBD_EP4CS, rx_str: "EP4 OUT RD",},
++};
++__u8 epl2p[6] = { 0x00, 0x02, 0x03, 0x04, 0x05, 0x00, }; // map logical to physical
++__u8 epp2l[6] = { 0x00, 0x00, 0x81, 0x82, 0x03, 0x04, }; // map physical to logical
++
++static __inline__ void au_fifo_read(struct ep_regs *ep, unsigned char * cp, int bytes)
++{
++ u32 rd = ep->rd;
++ for (; bytes--; *cp++ = au_readl(rd));
++}
++
++static __inline__ void au_fifo_write(int ep, unsigned char * cp, int bytes)
++{
++ u32 wr = ep_regs[ep].wr;
++ for (; bytes--; au_writel(*cp++, wr));
++ ep_regs[ep].last = bytes;
++}
++
++void __inline__ au_inten(u32 inten)
++{
++ au1x00_inten = inten;
++ au_writel(au1x00_inten, USBD_INTEN);
++}
++
++void __inline__ udc_epn_interrupt_enable(int epn)
++{
++ au_inten(au1x00_inten | (1 << epn));
++}
++
++void __inline__ udc_epn_interrupt_disable(int epn)
++{
++ au_inten(au1x00_inten & ~(1 << epn));
++ au_writel((1 << epn) , USBD_INTSTAT);
++}
++
++static void __inline__ send_zlp(unsigned char epn)
++{
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep_regs[epn].wrs);
++ au_writel(0 << 1, ep_regs[epn].cs);
++ au_writel(0, ep_regs[epn].wr);
++}
++/* ********************************************************************************************* */
++#define AU_DMA_HALT_POLL 0x1000
++static void __inline__ au_halt_dma(struct dma_chan *chan)
++{
++ int i;
++ au_writel(DMA_GO, chan->io + DMA_MODE_CLEAR);
++ for (i = 0; i < AU_DMA_HALT_POLL; i++)
++ RETURN_IF (au_readl(chan->io + DMA_MODE_READ) & DMA_HALT);
++ au_halt_dma_expired++;
++}
++
++static int __inline__ au_get_dma_residue(struct dma_chan *chan)
++{
++ int curBufCntReg = (au_readl(chan->io + DMA_MODE_READ) & DMA_AB) ? DMA_BUFFER1_COUNT : DMA_BUFFER0_COUNT;
++ return au_readl(chan->io + curBufCntReg) & DMA_COUNT_MASK;
++}
++
++static void __inline__ au_start_dma(struct dma_chan *chan, __u8 *bp, int len)
++{
++ if (au_readl(chan->io + DMA_MODE_READ) & DMA_AB) {
++ au_writel(DMA_D1, chan->io + DMA_MODE_CLEAR);
++ au_writel(len & DMA_COUNT_MASK, chan->io + DMA_BUFFER1_COUNT);
++ au_writel(0, chan->io + DMA_BUFFER0_COUNT);
++ au_writel(virt_to_phys(bp), chan->io + DMA_BUFFER1_START);
++ au_writel(DMA_BE1, chan->io + DMA_MODE_SET);
++ }
++ else {
++ au_writel(DMA_D0, chan->io + DMA_MODE_CLEAR);
++ au_writel(len & DMA_COUNT_MASK, chan->io + DMA_BUFFER0_COUNT);
++ au_writel(0, chan->io + DMA_BUFFER1_COUNT);
++ au_writel(virt_to_phys(bp), chan->io + DMA_BUFFER0_START);
++ au_writel(DMA_BE0, chan->io + DMA_MODE_SET);
++ }
++ au_writel(DMA_GO, chan->io + DMA_MODE_SET);
++}
++
++static void __inline__ au_start_dma_in(int indma, __u8 *bp, int len)
++{
++ au_start_dma(get_dma_chan(indma), bp, len);
++}
++
++static void __inline__ au_start_dma_out(int outdma, __u8 *bp, int wMaxPacketSize)
++{
++ dma_cache_inv((unsigned long) bp, wMaxPacketSize);
++ au_start_dma(get_dma_chan(outdma), bp, wMaxPacketSize);
++}
++
++static struct urb *au_rcv_complete_irq(struct usb_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ return bi_rcv_complete_irq(endpoint, len, urb_bad);
++}
++
++/* ********************************************************************************************* */
++/* au_start_in_ep0 - start transmit
++ */
++static void au_start_in_ep0 (struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct urb *urb = endpoint->tx_urb;
++ int last = ep->last = endpoint->last = MIN (urb->actual_length - endpoint->sent, endpoint->wMaxPacketSize);
++ TRACE_MSG16("START IN EP0 SENT: %d SENDING: %d", endpoint->sent, last);
++ RETURN_IF ((urb->actual_length - endpoint->sent) <= 0);
++ au_writel(last << 1, ep->cs); // XXX
++ au_fifo_write(0, urb->buffer + endpoint->sent, last);
++ endpoint->last = last;
++}
++
++/* au_in_ep0 - called to service an endpoint zero IN interrupt, data sent
++ */
++static void au_in_ep0(struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ u32 cs;
++ struct urb *tx_urb;
++ int last;
++ TRACE_MSG32("EP0 IN: tx_urb: %p", (int)endpoint->tx_urb);
++ if ((cs = au_readl(ep->cs)) & USBDEV_CS_STALL) { // clear stall if present
++ TRACE_MSG32("CLEAR STALL %d", 0);
++ cs &= ~USBDEV_CS_STALL;
++ au_writel(cs, ep->cs);
++ return;
++ }
++ if (!(tx_urb = bi_tx_complete_irq(endpoint, 0))) { // wait for setup if no more data
++ endpoint->state = WAIT_FOR_SETUP;
++ return;
++ }
++ TRACE_MSG8("EP0 IN actual: %d last: %d sent: %d flags: %x", endpoint->tx_urb->actual_length,
++ endpoint->last, endpoint->sent, endpoint->tx_urb->flags);
++ if (bi_tx_sendzlp(endpoint)) { // check if tx_urb we have is finished
++ TRACE_MSG("EP0 IN BULK - sending ZLP");
++ tx_urb->flags &= ~USBD_URB_SENDZLP;
++ send_zlp(0);
++ bi_tx_complete_irq(endpoint, 0);
++ return;
++ }
++ if (tx_urb->actual_length > endpoint->sent) {
++ if ((tx_urb->actual_length - endpoint->sent) < endpoint->wMaxPacketSize)
++ TRACE_MSG32("EP0 IN starting short packet %d", tx_urb->actual_length - endpoint->sent);
++ else
++ TRACE_MSG32("EP0 IN LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ au_start_in_ep0(endpoint, ep);
++ }
++}
++
++/* au_out_ep0 - called to service an endpoint zero OUT interrupt, data received
++ */
++static void au_out_ep0(struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usb_device_request request;
++ int i;
++ u32 cs;
++ u32 bytes;
++ TRACE_MSG("EP0 OUT");
++ cs = au_readl(ep->cs); // check if host aborted transfer and flush the write fifo
++ bytes = au_readl(ep->rds) & USBDEV_FSTAT_FCNT_MASK;
++ if (endpoint->state == DATA_STATE_RECV) {
++ struct urb *rcv_urb = bi_rcv_next_irq(endpoint);
++ TRACE_MSG32("EP0 OUT: RECV: rcv_urb: %x", (int) rcv_urb);
++ if (rcv_urb) {
++ au_fifo_read(ep, rcv_urb->buffer + rcv_urb->actual_length, bytes);
++ if (au_rcv_complete_irq(endpoint, bytes, 0))
++ return;
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ endpoint->state = WAIT_FOR_SETUP;
++ send_zlp(0);
++ return;
++ }
++ endpoint->state = WAIT_FOR_SETUP;
++ }
++ bi_tx_cancelled_irq(endpoint);
++ bi_rcv_cancelled_irq(endpoint);
++ au_fifo_read(ep, (u8 *)&request, bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs);
++ if (bytes != 8) {
++ TRACE_MSG32("ERROR SETUP SET not eight bytes: %d", bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs);
++ return;
++ }
++ TRACE_MSG8("SETUP bmRequestType: %02x bRequest %02x state: %d status: %d", request.bmRequestType,
++ request.bRequest, usbd_bus->device_state, usbd_bus->status);
++ switch (request.bRequest) { // we need to simply ignore any of these
++ case USB_REQ_SET_ADDRESS: // Fake a bus reset IFF not state default and then process normally
++ BREAK_IF (usbd_bus->device_state == STATE_DEFAULT);
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_irq (usbd_bus, DEVICE_RESET, 0);
++ usbd_bus_event_irq (usbd_bus, DEVICE_ADDRESS_ASSIGNED, 0);
++ break;
++ case USB_REQ_GET_DESCRIPTOR: // Fake a bus reset IFF suspended and then process normally
++ BREAK_IF (STATE_SUSPENDED != usbd_bus->device_state);
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_irq (usbd_bus, DEVICE_RESET, 0);
++ usbd_bus_event_irq (usbd_bus, DEVICE_ADDRESS_ASSIGNED, 0);
++ break;
++ }
++ if (bi_recv_setup_irq(&request)) {
++ TRACE_MSG32("ep0 STALL %d", cs);
++ au_writel(USBDEV_CS_STALL, USBD_EP0CS);
++ return;
++ }
++ if (((request.bmRequestType & USB_REQ_DIRECTION_MASK) == USB_REQ_HOST2DEVICE) && le16_to_cpu (request.wLength)) {
++ TRACE_MSG32("ep0 Class H2D request %04x", le16_to_cpu(request.wLength));
++ endpoint->state = DATA_STATE_RECV;
++ return;
++ }
++ if ((request.bmRequestType & USB_REQ_DIRECTION_MASK) == USB_REQ_HOST2DEVICE) {
++ TRACE_MSG32("ep0 Class H2D request %04x", le16_to_cpu(request.wLength));
++ if ((request.bmRequestType & ~USB_REQ_DIRECTION_MASK)) {
++ TRACE_MSG32("ep0 Class or Vendor, send ZLP %d", cs);
++ send_zlp(0);
++ return;
++ }
++ }
++ TRACE_MSG32("ep0 Class D2H request %04x", le16_to_cpu(request.wLength));
++}
++/* ********************************************************************************************* */
++/* au_start_in_bulk - start transmit
++ * The au1x00 will start to send when the first byte is loaded into the FIFO, either by
++ * DMA or PIO. The packetsize must be set first.
++ */
++static void au_start_in_bulk (unsigned int epn, struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct urb *urb = endpoint->tx_urb;
++ unsigned char *bp = urb->buffer + endpoint->sent;
++ int indma = ep->indma;
++ int last;
++ TRACE_MSG32("START IN BULK %d", epn);
++ RETURN_IF (!urb || (( (urb->actual_length - endpoint->sent) == 0) && !(urb->flags & USBD_URB_SENDZLP)));
++ last = ep->last = endpoint->last = MIN (urb->actual_length - endpoint->sent, endpoint->wMaxPacketSize);
++ TRACE_MSG16("START IN BULK sent: %d last:%d", endpoint->sent, last);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs); // XXX
++ if (!last) {
++ if (endpoint->tx_urb->flags & USBD_URB_SENDZLP) {
++ TRACE_MSG("START IN BULK - zending ZLP");
++ send_zlp(epn);
++ endpoint->tx_urb->flags &= ~USBD_URB_SENDZLP;
++ }
++ return;
++ }
++ else if (au1x00_new_silicon && (8 >= last)) {
++ au_writel(last << 1, ep->cs);
++ au_fifo_write(epn, bp, last);
++ return;
++ }
++ if (!au1x00_new_silicon)
++ udc_epn_interrupt_disable(epn);
++ dma_cache_wback_inv((unsigned long) bp, last);
++ au_writel(last << 1, ep->cs);
++ au_start_dma_in(indma, bp, last);
++}
++
++static void au_in_bulk(unsigned int epn, struct ep_regs *ep, struct usb_endpoint_instance *endpoint)
++{
++ struct urb *tx_urb;
++ int rc = 0;
++ u32 cs = au_readl(ep->cs);
++ u32 wrs = au_readl(ep->wrs);
++ TRACE_MSG16("BULK IN EPN - cs: %x wrs: %x", cs, wrs);
++ if (!au1x00_new_silicon)
++ if (epn && (ep->last > 8)) {
++ TRACE_MSG16("BULK IN EPN - DMA ACTIVE epn %d last %d", epn, ep->last);
++ udc_epn_interrupt_disable(epn);
++ return;
++ }
++ if (wrs) { // check for underflow or overflow
++ rc = 1;
++ if (wrs & USBDEV_FSTAT_UF) {
++ TRACE_MSG16("BULK IN EPN - UF epn %d wrs: %x", epn, wrs);
++ rc = 1; // set rc to indicate an error
++ }
++ if (wrs & USBDEV_FSTAT_OF)
++ TRACE_MSG16("BULK IN EPN - OF epn %d wrs: %x", epn, wrs);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs); // flush the fifo
++ }
++ if (cs & USBDEV_CS_NAK) {
++ RETURN_IF (ep->last && ((wrs&0x1f) == ep->last));
++ rc = 1;
++ }
++ if (cs & USBDEV_CS_STALL) { // clear stall if present
++ TRACE_MSG32("BULK IN EPN - CLEAR STALL %d", epn);
++ cs &= ~USBDEV_CS_STALL;
++ au_writel(cs, ep->cs);
++ return;
++ }
++ TRACE_MSG8("BULK IN EPN epn: %d rc: %d last: %d sent: %d", epn, rc, endpoint->last, endpoint->sent);
++ if ((tx_urb = bi_tx_complete_irq(endpoint, rc))) {
++ if ((tx_urb->actual_length > endpoint->sent) || (endpoint->tx_urb->flags & USBD_URB_SENDZLP)) {
++ au_start_in_bulk(epl2p[endpoint->bEndpointAddress&0xf], endpoint, ep);
++ /* XXX magic delay - without this large packets will eventually stall the transmit
++ * XXX and all traffic in both directions will stop.
++ */
++ if (!au1x00_new_silicon)
++ udelay(8);
++ TRACE_MSG32("BULK IN EPN - LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ return;
++ }
++ }
++ udc_epn_interrupt_disable(epn); // disable interrupts
++}
++
++/* au_start_in_iso - start transmit
++ * The au1x00 will start to send when the first byte is loaded into the FIFO, either by DMA or
++ * PIO. The packetsize must be set first.
++ */
++static void au_start_in_iso (unsigned int epn, struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct urb *urb = endpoint->tx_urb;
++ unsigned char *bp = urb->buffer + endpoint->sent;
++ int last;
++ TRACE_MSG16("START IN ISO actual: %d sent: %d", urb->actual_length, endpoint->sent);
++ RETURN_IF ((urb->actual_length - endpoint->sent) == 0);
++ last = ep->last = endpoint->last = MIN (urb->actual_length - endpoint->sent, endpoint->wMaxPacketSize);
++ TRACE_MSG16("START IN ISO last: %d packetSize: %d", last, endpoint->wMaxPacketSize);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs); // XXX
++ au1x00_new_silicon ? udc_epn_interrupt_enable : udc_epn_interrupt_disable (epn);
++ dma_cache_wback_inv((unsigned long) bp, last);
++ au_writel(last << 1, ep->cs);
++ au_start_dma_in(ep->indma, bp, last);
++}
++
++static void au_in_iso(unsigned int epn, struct ep_regs *ep, struct usb_endpoint_instance *endpoint)
++{
++ struct urb *tx_urb = bi_tx_complete_irq(endpoint, 0);
++ u32 cs = au_readl(ep->cs);
++ u32 wrs = au_readl(ep->wrs);
++ TRACE_MSG16("ISO IN EPN - cs: %x wrs: %x", cs, wrs);
++ if (!au1x00_new_silicon)
++ if (epn && (ep->last > 8)) {
++ udc_epn_interrupt_disable(epn);
++ return;
++ }
++ TRACE_MSG8("ISO IN EPN epn: %d last: %d sent: %d", epn, endpoint->last, endpoint->sent, 0);
++ ep->last = 0;
++ if ((tx_urb = endpoint->tx_urb) && (tx_urb->actual_length > endpoint->sent)) {
++ au_start_in_iso(epl2p[endpoint->bEndpointAddress&0xf], endpoint, ep);
++ /* XXX magic delay - without this large packets will eventually stall the transmit
++ * XXX and all traffic in both directions will stop.
++ */
++ if (!au1x00_new_silicon)
++ udelay(8);
++ TRACE_MSG32("ISO IN EPN - LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ return;
++ }
++ else
++ TRACE_MSG("ISO IN EPN - nothing to send");
++ udc_epn_interrupt_disable(epn); // disable interrupts
++}
++/* ********************************************************************************************* */
++
++static void au_start_out_bulk(unsigned int epn, struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ int outdma = ep->outdma;
++ TRACE_MSG16("START OUT BULK %d %d", epn, endpoint->wMaxPacketSize);
++ if (!endpoint->rcv_urb) {
++ TRACE_MSG("START OUT BULK DISABLE");
++ udc_epn_interrupt_disable(epn);
++ return;
++ }
++ if (endpoint->rcv_error) {
++ TRACE_MSG("START OUT BULK reseting rcv_error");
++ endpoint->rcv_error = 0;
++ }
++ au_start_dma_out(outdma, endpoint->rcv_urb->buffer + endpoint->rcv_urb->actual_length, endpoint->wMaxPacketSize);
++}
++
++static void au_out_bulk(unsigned int epn, struct ep_regs *ep, struct usb_endpoint_instance *endpoint)
++{
++ int bytes = 0;
++ int outdma = ep->outdma;
++ struct dma_chan *chan = get_dma_chan(outdma);
++ struct urb *urb;
++ struct urb *completed_urb = NULL;
++ u32 cs;
++ u32 rds;
++ u32 nrds;
++ au_halt_dma(chan);
++ cs = au_readl(ep->cs);
++ rds = au_readl(ep->rds);
++ TRACE_MSG16("BULK OUT CS: %04x RD: %04x", cs, rds);
++ bytes = endpoint->wMaxPacketSize - au_get_dma_residue(chan);
++ if (!(urb = bi_rcv_next_irq(endpoint))) {
++ TRACE_MSG("BULK OUT EPN - no rcv_urb");
++ udc_epn_interrupt_disable(epn);
++ return;
++ }
++ /* The original AU1X00 UDC design will continue to receive data as long as there is room
++ * in the FIFO. We cannot tell when we are at the end of a packet and/or have the start
++ * of a new one.
++ *
++ * There are only two scenarios that are guaranteed (almost) to be correct:
++ *
++ * 64 bytes of data from DMA, empty fifo, continue Bulk OUT < 60 bytes of data and
++ * < 4 bytes in fifo, end Bulk OUT.
++ *
++ * There may be a third scenario that is ok:
++ *
++ * 0 bytes dma, 0 bytes in fifo, NAK
++ *
++ * Everything else is an error. In all cases we assume that it is safer to drop data
++ * than to accept it in error. This allows CRC or size protected encapsulations to
++ * notice bulk transfers received with errors.
++ *
++ * In general none of the policies or strategies are able to cope with all errors
++ * without missing errors and dropping good data. The intent is to minimize the amount
++ * of potentially bad data getting to the function driver while minimizing the amount of
++ * good data that is dropped.
++ *
++ * The new silicon mitigates this problem for non control endpoints because it will NAK
++ * additional data until the interrupt service flag is reset.
++ *
++ * Start with generic error tests, OF, UF or NAK indicate an error we cannot recover
++ * from, start flushing until end of current bulk transfer (wait for a short packet)
++ *
++ */
++ if (rds & (USBDEV_FSTAT_OF | USBDEV_FSTAT_UF)) {
++ TRACE_MSG16("BULK OUT FLUSHING %d length: %d", bytes, urb->actual_length);
++ THROW(start_flushing);
++ }
++ rds = rds & USBDEV_FSTAT_FCNT_MASK;
++ nrds = au_readl(ep->rds);
++ if (64 == bytes) {
++ TRACE_MSG16("BULK OUT 64 BYTES %d length: %d", bytes, urb->actual_length);
++ /* full size packet received, check that we are not flushing and that the FIFO
++ * does not have any data. If there is data in the FIFO we may not be able to
++ * restart DMA in time, so start flushing
++ */
++ if (endpoint->rcv_error) {
++ TRACE_MSG8("FULL PACKET bytes: %d rds: %d nrds: %d cp0: %d CONTINUE FLUSHING",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ if ((nrds > 6) && (nrds < 8) ) {
++ TRACE_MSG8("FIFO not empty bytes: %d rds: %d nrds: %d cp0: %d START FLUSHING nrds > 6 < 8",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ if (!urb->actual_length)
++ TRACE_MSG8("PACKET ok bytes: %d rds: %d nrds: %d cp0: %d ACCEPTING 64 bytes",
++ bytes, rds, nrds, cp0_count);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ au_rcv_complete_irq(endpoint, 64, 0);
++ if (cs & USBDEV_CS_NAK)
++ if (nrds && (nrds < 8) ) {
++ TRACE_MSG8("NAK bytes: %d rds: %d nrds: %d cp0: %d START FLUSHING CS_NAK",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ }
++ else if ((cs & USBDEV_CS_NAK) && (!nrds || (nrds == 8)) ) {
++ TRACE_MSG16("BULK OUT NAK BYTES %d length: %d", bytes, urb->actual_length);
++ /* a nak'd packet may be ok to ignore IFF the FIFO is empty(?) or completely full.
++ */
++ if (endpoint->rcv_error) {
++ TRACE_MSG8("NAK bytes: %d rds: %d nrds: %d cp0: %d CONTINUE FLUSHING",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ }
++ else {
++ TRACE_MSG16("BULK OUT < 64 BYTES %d length: %d", bytes, urb->actual_length);
++ /* short packet by DMA, additional data for this packet in FIFO, more than 3
++ * bytes is probably an error.
++ */
++ if ((cs & USBDEV_CS_NAK) && nrds && (nrds < 8) ) {
++ TRACE_MSG8("BULK OUT NAK bytes: %d rds: %d nrds: %d cp0: %d START FLUSHING",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ if (nrds > 4) {
++ TRACE_MSG8("BULK OUT SHORT PACKET by DMA full FIFO bytes: %d rds: %d nrds: %d cp0: %d START FLUSHING",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ TRACE_MSG8("BULK OUT SHORT bytes: %d rds: %d nrds: %d cp0: %d reading fifo", bytes, rds, nrds, cp0_count);
++ au_fifo_read(ep, urb->buffer + urb->actual_length + bytes, nrds);
++ bytes += nrds;
++ TRACE_MSG32("BULK OUT < 64 BYTES %d", bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ if (!endpoint->rcv_error) {
++ TRACE_MSG("BULK OUT COMPLETED URB");
++ au_rcv_complete_irq(endpoint, bytes, 0);
++ }
++ else {
++ TRACE_MSG("BULK OUT - FLUSHING URB - reseting rcv_error");
++ endpoint->rcv_error = 0;
++ }
++ }
++ CATCH(start_flushing) {
++ TRACE_MSG("BULK OUT - START FLUSHING URB");
++ endpoint->rcv_error = 1;
++ endpoint->rcv_urb->actual_length = 0;
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ bytes = 0;
++ }
++ TRACE_MSG("BULK OUT - RESTARTING");
++ au_start_out_bulk(epn, endpoint, ep);
++}
++
++static void au_start_out_iso(unsigned int epn, struct usb_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ int outdma = ep->outdma;
++ RETURN_IF(!endpoint->rcv_urb);
++ au_start_dma_out(outdma, endpoint->rcv_urb->buffer + endpoint->rcv_urb->actual_length, endpoint->wMaxPacketSize);
++}
++
++static void au_out_iso(unsigned int epn, struct ep_regs *ep, struct usb_endpoint_instance *endpoint)
++{
++ int bytes = 0;
++ int outdma = ep->outdma;
++ struct dma_chan *chan = get_dma_chan(outdma);
++ struct urb *urb;
++ u32 cs;
++ u32 rds;
++ au_halt_dma(chan);
++ cs = au_readl(ep->cs);
++ rds = au_readl(ep->rds);
++ if (!endpoint) {
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ return;
++ }
++ if (!(urb = endpoint->rcv_urb)) {
++ TRACE_MSG16("ISO OUT EPN - rcv_urb was NULL bytes: %d rds: %d", bytes, rds);
++ au_rcv_complete_irq(endpoint, bytes, 1);
++ TRACE_MSG("ISO OUT setting rcv_error");
++ }
++ bytes = endpoint->wMaxPacketSize - au_get_dma_residue(chan);
++ rds = rds & USBDEV_FSTAT_FCNT_MASK;
++ au_fifo_read(ep, urb->buffer + urb->actual_length + bytes, rds);
++ bytes += rds;
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ au_rcv_complete_irq(endpoint, bytes, 0);
++ au_start_out_iso(epn, endpoint, ep);
++}
++/* ********************************************************************************************* */
++/* udc_tx_dma_done - TX DMA interrupt handler
++ */
++static void udc_tx_dma_done(int irq, void *dev_id, struct pt_regs *regs)
++{
++ int epn = (int) dev_id;
++ struct usb_endpoint_instance *endpoint = usbd_bus->endpoint_array + epn;
++ struct ep_regs *ep = &ep_regs[epn];
++ int residue;
++ int indma = irq - 6;
++ struct dma_chan *chan = get_dma_chan(indma);
++ u32 mode = au_readl(chan->io + DMA_MODE_READ);
++ udc_interrupts++;
++ TRACE_MSG32("TX DMA done: mode: %x", mode);
++ if (mode & DMA_D0)
++ au_writel(DMA_D0, chan->io + DMA_MODE_CLEAR);
++ if (mode & DMA_D1)
++ au_writel(DMA_D1, chan->io + DMA_MODE_CLEAR);
++ RETURN_IF (!epn);
++ au_halt_dma(chan);
++ residue = au_get_dma_residue(chan);
++ TRACE_MSG16("TX DMA IRQ - epn %d residue %d", epn, residue);
++ if (!au1x00_new_silicon) {
++ /* XXX magic delay - without this large packets will eventually stall the transmit
++ * XXX and all traffic in both directions will stop.
++ */
++ udelay(8);
++ bi_tx_complete_irq (endpoint, residue?1:0);
++ udc_epn_interrupt_enable(epl2p[endpoint->bEndpointAddress&0xf]);
++ }
++ ep->last = 0;
++}
++
++/* udc_int_req - usb interrupt handler
++ */
++static void udc_int_req (int irq, void *dev_id, struct pt_regs *regs)
++{
++ u32 intstat;
++ struct ep_regs *ep;
++#if defined(MAX_INTR_LOOP_STATS)
++ u32 loopcount = 0;
++#endif
++#ifdef RECORD_LATENCY
++ cp0_count = (read_c0_count(CP0_COUNT) - cp0_record) >> 9;
++ if (cp0_count < CP0_COUNTS)
++ cp0_counts[cp0_count]++;
++#endif
++#ifdef CHECK_LATENCY
++ u32 cp0_count = read_c0_count(CP0_COUNT);
++#endif
++ udc_interrupts++;
++#if 0
++ if (udc_interrupts > 2000) {
++ TRACE_MSG("UDC_INT call udc_disable_interrupts");
++ au_inten(0);
++ return;
++ }
++#endif
++ while (( intstat = au_readl(USBD_INTSTAT) & au1x00_inten)) { // read and reset interrupt status register
++
++ int epn;
++#if 1
++ for (epn = 2; epn < 6; epn++) {
++ CONTINUE_IF (!(intstat & (1 << epn)));
++#else
++ // NOT TESTED
++ u32 local_intstat = intstat;
++ TRACE_MSG16("INTSTAT: %04x %04x", intstat, au_readl(USBD_INTEN));
++ while (local_intstat & 0x3f) {
++ int epn = 31 - au_clz(local_intstat);
++ local_intstat &= ~(1<<epn);
++#endif
++ if (udc_saw_bus_activity) {
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_irq (usbd_bus, DEVICE_BUS_ACTIVITY, 0);
++ }
++ ep = &ep_regs[epn];
++ switch(ep->eptype) {
++ case USB_DIR_IN | USB_ENDPOINT_BULK:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT:
++ //TRACE_MSG16("BULK IN %d %02x", epn, ep->eptype);
++ au_in_bulk(epn, ep, usbd_bus->endpoint_array + epn);
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ //TRACE_MSG16("ISO IN %d %02x", epn, ep->eptype);
++ au_in_iso(epn, ep, usbd_bus->endpoint_array + epn);
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_BULK:
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT:
++ //TRACE_MSG16("BULK OUT %d %02x", epn, ep->eptype);
++ au_out_bulk(epn, ep, usbd_bus->endpoint_array + epn);
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ //TRACE_MSG16("ISO OUT %d %04d", epn, au_readl(NUSBD_FRAMENUM));
++ au_out_iso(epn, ep, usbd_bus->endpoint_array + epn);
++ break;
++ }
++ }
++ au_writel(intstat, USBD_INTSTAT); // Only clear the interrupt(s) AFTER servicing OUT
++ /* even though we disable the bulk-in interrupt (endpoint 2) prior to enabling
++ * DMA we always see one additional interrupt that is a NAK on that endpoint.
++ */
++ CONTINUE_IF(!(intstat & au1x00_inten));
++ /* handle control endpoint and suspend interrupt
++ */
++ if (intstat & ( ((1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | USBDEV_INT_SOF))) {
++ if (intstat & (1 << 0))
++ au_out_ep0(usbd_bus->endpoint_array + 0, &ep_regs[0]);
++ if (intstat & (1 << 1))
++ au_in_ep0(usbd_bus->endpoint_array + 0, &ep_regs[0]);
++ if (intstat & USBDEV_INT_SOF)
++ if (USBD_SUSPENDED == usbd_bus->status) {
++ TRACE_MSG("SUS - ACTIVITY");
++ udc_saw_bus_activity++;
++ }
++ }
++#if defined(MAX_INTR_LOOP_STATS)
++ loopcount += 1; // Gather stats on how many times this loop is performed.
++#endif
++ }
++#if defined(MAX_INTR_LOOP_STATS)
++ interrupt_loop_stats[MIN(loopcount, MAX_INTR_LOOP_STATS)]++;
++#endif
++#if defined(CHECK_LATENCY)
++ TRACE_MSG32("USB IRQ - %d", read_c0_count(CP0_COUNT) - cp0_count);
++#endif
++#if defined(RECORD_LATENCY)
++ cp0_record = read_c0_count(CP0_COUNT);
++#endif
++}
++
++/* udc_int_sus -suspend interrupt handler
++ */
++static void udc_int_sus (int irq, void *dev_id, struct pt_regs *regs)
++{
++ udc_interrupts++;
++ TRACE_MSG16("SUS - INACTIVE device: %d status: %d", usbd_bus->device_state, usbd_bus->status);
++ switch(usbd_bus->status) {
++ case USBD_OPENING:
++ case USBD_OK:
++ usbd_bus_event_irq (usbd_bus, DEVICE_BUS_INACTIVE, 0);
++ break;
++ default:
++ break;
++ }
++}
++/* ********************************************************************************************* */
++/* udc_start_endpoint_in - start transmit
++ */
++void udc_start_endpoint_in(struct usb_endpoint_instance *endpoint)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ TRACE_MSG16("UDC START IN %02x %d", endpoint->bEndpointAddress, epn);
++ TRACE_MSG16("UDC START IN len: %d flags: %x", (unsigned int)endpoint->tx_urb->actual_length, endpoint->tx_urb->flags);
++ switch(endpoint->bmAttributes & USB_ENDPOINT_MASK) {
++ case USB_ENDPOINT_CONTROL:
++ TRACE_MSG32("UDC START IN EP0 %p", (u32)endpoint->rcv_urb);
++ au_in_ep0(endpoint, ep);
++ break;
++ case USB_ENDPOINT_BULK:
++ case USB_ENDPOINT_INTERRUPT:
++ TRACE_MSG32("UDC START IN BULK %p", (u32)endpoint->rcv_urb);
++ au_start_in_bulk(epn, endpoint, ep);
++ break;
++ case USB_ENDPOINT_ISOCHRONOUS:
++ TRACE_MSG32("UDC START IN ISO %p", (u32)endpoint->rcv_urb);
++ au_start_in_iso(epn, endpoint, ep);
++ break;
++ }
++ if (au1x00_new_silicon)
++ udc_epn_interrupt_enable(epn);
++}
++
++/* udc_start_endpoint_out - start receive
++ */
++void udc_start_endpoint_out(struct usb_endpoint_instance *endpoint)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ TRACE_MSG16("UDC START OUT %02x %d", endpoint->bEndpointAddress, epn);
++ TRACE_MSG32("UDC START OUT len: %d", endpoint->rcv_urb->buffer_length);
++ switch(endpoint->bmAttributes & USB_ENDPOINT_MASK) {
++ case USB_ENDPOINT_CONTROL:
++ TRACE_MSG32("UDC START OUT EP0 %p", (u32)endpoint->rcv_urb);
++ break;
++ case USB_ENDPOINT_BULK:
++ case USB_ENDPOINT_INTERRUPT:
++ TRACE_MSG32("UDC START OUT BULK %p", (u32)endpoint->rcv_urb);
++ au_start_out_bulk(epn, endpoint, ep);
++ udc_epn_interrupt_enable(epn);
++ break;
++ case USB_ENDPOINT_ISOCHRONOUS:
++ TRACE_MSG32("UDC START OUT ISO %p", (u32)endpoint->rcv_urb);
++ au_start_out_iso(epn, endpoint, ep);
++ break;
++ }
++}
++
++void udc_cancel_in_irq(struct urb *urb)
++{
++ int epn = epl2p[urb->endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ TRACE_MSG("CANCEL IN URB");
++ au_in_bulk(epn, ep, urb->endpoint);
++}
++
++void udc_cancel_out_irq(struct urb *urb)
++{
++ int epn = epl2p[urb->endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ TRACE_MSG("CANCEL OUT URB");
++ if (epn)
++ au_out_bulk(epn, ep, urb->endpoint);
++}
++
++/* udc_init - initialize
++ */
++int udc_init (void)
++{
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
++#undef read_c0_prid
++#define read_c0_prid() read_32bit_cp0_register(CP0_PRID)
++#endif
++ u32 cp0_prid = read_c0_prid();
++ switch (cp0_prid & CP0_PRID_SOC_MASK) {
++ case CP0_PRID_AU1000:
++ case CP0_PRID_AU1100:
++ au1x00_new_silicon = (cp0_prid & CP0_PRID_REV_MASK) >= 4;
++ printk(KERN_INFO"%s: AU1100 cp0_prid: new: %d\n", __FUNCTION__, au1x00_new_silicon);
++ break;
++ case CP0_PRID_AU1500:
++ au1x00_new_silicon = (cp0_prid & CP0_PRID_REV_MASK) >= 2;
++ printk(KERN_INFO"%s: AU1500 cp0_prid: new: %d\n", __FUNCTION__, au1x00_new_silicon);
++ break;
++ default:
++ printk(KERN_INFO"%s: UNKNOWN CPU cp0_prid: %08x UNKNOWN UDC\n", __FUNCTION__, cp0_prid);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/* udc_serial_init - set a serial number if available
++ */
++int udc_serial_init (void)
++{
++#if defined(CONFIG_MIPS_FREEHAND)
++ int length;
++ long data[16]; /* yeah a hack, but we KNOW it's 16 */
++ struct i2c_client *client;
++ char chData[16];
++ int i;
++
++ if (!(client = getFreeHandEepromClient())) {
++ printk(KERN_INFO"eeprom not ready when udc_serial_init called\n");
++ return -EINVAL;
++ }
++ eeprom_contents(client, SENSORS_PROC_REAL_READ, EEPROM_SYSCTL1, &length, (long *)data);
++
++ /* serial number is first 9 longs. But each long is just an ASCII char
++ * convert this to a string and then extract a 4 byte value from it
++ */
++ for (i = 0; i < 9; chData[i] = (char)data[i], i++); /* trunc, is ok */
++ chData[9] = 0; /* terminate string */
++ printk(KERN_INFO"%s: %s\n", __FUNCTION__, chData);
++ usbd_bus->serial_number_str = lstrdup(chData);
++ return 0;
++#else
++ return -EINVAL;
++#endif
++}
++
++/* udc_setup_ep - setup endpoint
++ */
++void udc_setup_ep (unsigned int epn, struct usb_endpoint_instance *endpoint)
++{
++ RETURN_IF (epn);
++ endpoint->state = WAIT_FOR_SETUP;
++}
++
++/* udc_attached - is the USB cable connected
++ * Return non-zero if cable is connected.
++ *
++ * udc_connect - enable pullup resistor
++ * Turn on the USB connection by enabling the pullup resistor.
++ *
++ * udc_disconnect - disable pullup resistor
++ * Turn off the USB connection by disabling the pullup resistor.
++ */
++
++#if defined(CONFIG_MIPS_PICOENGINE_MVCI)
++int udc_attached (void)
++{
++ return 1;
++}
++
++int udc_connected(void)
++{
++ return udc_connected_status;
++}
++
++void udc_connect (void)
++{
++ extern void pico_mvci_set_usb_pullup(int);
++ pico_mvci_set_usb_pullup(1);
++ udc_connected_status = 1;
++}
++
++void udc_disconnect (void)
++{
++ extern void pico_mvci_set_usb_pullup(int);
++ pico_mvci_set_usb_pullup(0);
++ udc_connected_status = 0;
++}
++
++#elif defined(CONFIG_MIPS_FREEHAND_NATIVE)
++/* have to do this because version A boards don't have pullups
++ * XXX checkme
++*/
++int udc_attached (void)
++{
++ return 1;
++}
++
++int udc_connected(void)
++{
++ return udc_connected_status;
++}
++
++void udc_connect (void)
++{
++ au1000gpio_set(GPIO01);
++ udc_connected_status = 1;
++}
++
++void udc_disconnect (void)
++{
++ au1000gpio_clear(GPIO01);
++ udc_connected_status = 0;
++}
++
++#endif
++
++/* udc_framenum - get current framenum
++ */
++int udc_framenum (void)
++{
++ return au_readl(NUSBD_FRAMENUM);
++}
++
++/* udc_all_interrupts - enable interrupts
++ */
++void udc_all_interrupts (void)
++{
++ au_inten(0x0033|USBDEV_INT_SOF); // Only enable receive interrupts.
++}
++
++/* udc_suspended_interrupts - enable suspended interrupts
++ */
++void udc_suspended_interrupts (void)
++{
++ au_inten(0x0033|USBDEV_INT_SOF);
++}
++
++/* udc_disable_interrupts - disable interrupts.
++ */
++void udc_disable_interrupts (void)
++{
++ au_inten(0);
++}
++
++/* udc_disable - disable the UDC
++ */
++void udc_disable (void)
++{
++ au_writel(0x0000, USBD_ENABLE);
++}
++
++/* udc_release_udc_irq - release UDC irq
++ */
++void udc_release_udc_irq (void)
++{
++ free_irq (AU1000_USB_DEV_REQ_INT, NULL);
++ free_irq (AU1000_USB_DEV_SUS_INT, NULL);
++#if defined(MAX_INTR_LOOP_STATS)
++ {
++ u32 lc;
++ for (lc = 0; lc <= MAX_INTR_LOOP_STATS; lc++)
++ if (interrupt_loop_stats[lc])
++ printk(KERN_ERR "%s: interrupt loopcount[%02u] %9u\n", __FUNCTION__, lc,interrupt_loop_stats[lc]);
++ printk(KERN_INFO"%s: halt_dma_expired: %d\n", __FUNCTION__, au_halt_dma_expired);
++ }
++#endif
++#ifdef RECORD_LATENCY
++ {
++ int i;
++ for (i = 0; i < CP0_COUNTS; i++)
++ if (cp0_counts[i])
++ printk(KERN_INFO"%s: cp0_counts[%d] %d\n", __FUNCTION__, i, cp0_counts[i]);
++ }
++#endif
++}
++
++/* udc_request_udc_irq - request UDC interrupt
++ */
++int udc_request_udc_irq (void)
++{
++ RETURN_EINVAL_IF (request_irq (AU1000_USB_DEV_REQ_INT, udc_int_req, SA_INTERRUPT, UDC_NAME "UDC Req", NULL));
++ if (request_irq (AU1000_USB_DEV_SUS_INT, udc_int_sus, SA_INTERRUPT, UDC_NAME "UDC Sus", NULL) != 0) {
++ udc_release_udc_irq();
++ free_irq (AU1000_USB_DEV_REQ_INT, NULL);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++static int request_dma(int ep, int id, char *str, void dma_done(int , void *, struct pt_regs *))
++{
++ int dma;
++ if ((dma = request_au1000_dma(id, str, dma_done, SA_INTERRUPT | SA_SAMPLE_RANDOM, (void *)ep)) < 0) {
++ printk(KERN_INFO"request_io[%d] dma: %d id: %x %s FAILED\n", ep, dma, id, str);
++ return -1;
++ }
++ return dma;
++}
++
++/* udc_request_io - request IO region
++ */
++int udc_request_io (void)
++{
++ int i;
++ for (i = 0; i < 6; i++) {
++ ep_regs[i].indma = ep_regs[i].tx_id ? request_dma(i, ep_regs[i].tx_id, ep_regs[i].tx_str, udc_tx_dma_done) : -1;
++ ep_regs[i].outdma = ep_regs[i].rx_id ? request_dma(i, ep_regs[i].rx_id, ep_regs[i].rx_str, NULL) : -1;
++ }
++ return 0;
++}
++
++/* udc_release_io - release IO region
++ */
++void udc_release_io (void)
++{
++ int j;
++ for (j = 0; j < 6; j++) {
++ struct ep_regs *ep = &ep_regs[j];
++ if (ep->indma != -1) {
++ free_au1000_dma(ep->indma);
++ ep->indma = -1;
++ }
++ if (ep->outdma != -1) {
++ free_au1000_dma(ep->outdma);
++ ep->outdma = -1;
++ }
++ }
++}
++
++int udc_assign_endpoint( __u8 physicalEndpoint, int used[6], struct usb_endpoint_map *endpoint_map, __u8 bmAttributes,
++ __u16 wMaxPacketSize, __u16 transferSize)
++{
++ struct ep_regs *ep = &ep_regs[physicalEndpoint];
++ RETURN_EINVAL_IF(used[physicalEndpoint]);
++ endpoint_map->bEndpointAddress[0] = epp2l[physicalEndpoint];
++ endpoint_map->physicalEndpoint[0] = physicalEndpoint;
++ endpoint_map->wMaxPacketSize[0] = wMaxPacketSize;
++ endpoint_map->transferSize[0] = transferSize;
++ endpoint_map->bmAttributes[0] = bmAttributes;
++ used[physicalEndpoint]++;
++ ep->eptype = bmAttributes & 0x83;
++ return 0;
++}
++
++int udc_request_endpoints(struct usb_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usb_endpoint_request *requestedEndpoints)
++{
++ struct usb_device_description *device_description;
++ int i;
++ int used[6];
++ memset(used, 0, sizeof(used));
++ for (i = 0; i < endpointsRequested; i++) {
++ struct usb_endpoint_map *endpoint_map = endpoint_map_array + i;
++ u8 bmAttributes = requestedEndpoints[i].bmAttributes;
++ u16 transferSize = requestedEndpoints[i].fs_requestedTransferSize;
++ endpoint_map->bmAttributes[0] = bmAttributes;
++ endpoint_map->wMaxPacketSize[0] = 0x40;
++ switch(bmAttributes) {
++ case USB_DIR_OUT | USB_ENDPOINT_BULK:
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT:
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT:
++ CONTINUE_IF(!udc_assign_endpoint(4, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ CONTINUE_IF(!udc_assign_endpoint(5, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ CONTINUE_IF(!udc_assign_endpoint(4, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ CONTINUE_IF(!udc_assign_endpoint(5, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_BULK:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT:
++ CONTINUE_IF(!udc_assign_endpoint(2, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ CONTINUE_IF(!udc_assign_endpoint(3, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ CONTINUE_IF(!udc_assign_endpoint(2, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ CONTINUE_IF(!udc_assign_endpoint(3, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ break;
++ }
++ CONTINUE_IF(bmAttributes & USB_ENDPOINT_OPT);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++int udc_set_endpoints(int endpointsRequested, struct usb_endpoint_map *endpoint_map_array)
++{
++ int i, j;
++ __u8 config[25];
++ __u8 *cp;
++ memcpy(config, au1x00_config_bulk, sizeof(config));
++ for (i = 0; i < endpointsRequested; i++) {
++ struct usb_endpoint_map *endpoint_map = endpoint_map_array + i;
++ int epreq = endpoint_map->bmAttributes[0];
++ int eptype = epreq & USB_ENDPOINT_MASK;
++ int epdir = epreq & USB_ENDPOINT_DIR_MASK ? 0x8 : 0;
++ int epsize = endpoint_map->wMaxPacketSize[0];
++ int epaddr = epp2l[endpoint_map->physicalEndpoint[0]];
++ CONTINUE_IF(!endpoint_map->physicalEndpoint[0] || (endpoint_map->physicalEndpoint[0] > 5));
++ cp = config + ((endpoint_map->physicalEndpoint[0] - 1) * 5);
++ cp[0] = (epaddr & 0xf) << 4 | 0x4;
++ cp[1] = (eptype << 4) | epdir | (epsize & 0x380) >> 7;
++ cp[2] = (epsize & 0x7F) << 1;
++ }
++ au_inten(0); // disable interrupts
++ au_writel(0x0002, USBD_ENABLE); // reset controller
++ udelay(100);
++ au_writel(0x0003, USBD_ENABLE); // enable controller
++ udelay(100);
++ for (cp = config, i = 0; i < 25; i++, au_writel(*cp++, USBD_CONFIG)); // feed the config into the UDC
++ return 0;
++}
++/* ********************************************************************************************* */
++struct udc_ops udc_ops = {
++ max_endpoints: UDC_MAX_ENDPOINTS,
++ ep0_packetsize: EP0_PACKETSIZE,
++ name: UDC_NAME,
++ start_endpoint_in: udc_start_endpoint_in,
++ start_endpoint_out: udc_start_endpoint_out,
++ request_endpoints: udc_request_endpoints,
++ set_endpoints: udc_set_endpoints,
++ cancel_in_irq: udc_cancel_in_irq,
++ cancel_out_irq: udc_cancel_out_irq,
++ setup_ep: udc_setup_ep,
++#if defined(CONFIG_MIPS_PICOENGINE_MVCI) ||defined(CONFIG_MIPS_FREEHAND_NATIVE)
++ attached: udc_attached,
++ connected: udc_connected,
++ connect: udc_connect,
++ disconnect: udc_disconnect,
++#endif
++ framenum: udc_framenum,
++ all_interrupts: udc_all_interrupts,
++ suspended_interrupts: udc_suspended_interrupts,
++ disable_interrupts: udc_disable_interrupts,
++ disable: udc_disable,
++ init: udc_init,
++ request_udc_irq: udc_request_udc_irq,
++ release_udc_irq: udc_release_udc_irq,
++ release_io: udc_release_io,
++ serial_init: udc_serial_init,
++ request_io: udc_request_io,
++};
++
+diff -Nru a/drivers/usbd/au1x00_bi/au1x00.h b/drivers/usbd/au1x00_bi/au1x00.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/au1x00_bi/au1x00.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,112 @@
++/*
++ * usbd/au1x00_bi/au1100.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++/*
++ * au1100
++ *
++ * The au1100 does not seem to work properly with an 8 byte
++ * packetsize. So 16, 32 or 64 are the only valid values.
++ *
++ * Unfortunately this means that a DMA channel is required for
++ * EP0 transmit.
++ */
++
++#define EP0_PACKETSIZE 0x8
++
++#define UDC_MAX_ENDPOINTS 6
++
++#define UDC_NAME "AU1100"
++
++#define NUSBD_EP0RD 0xB0200000
++#define NUSBD_EP0WR 0xB0200004
++#define NUSBD_EP1WR 0xB0200008
++#define NUSBD_EP2WR 0xB020000C
++#define NUSBD_EP3RD 0xB0200010
++#define NUSBD_EP4RD 0xB0200014
++
++#define NUSBD_EP0CS 0xB0200024
++#define NUSBD_EP1CS 0xB0200028
++#define NUSBD_EP2CS 0xB020002C
++#define NUSBD_EP3CS 0xB0200030
++#define NUSBD_EP4CS 0xB0200034
++
++#define NUSBD_EP0RDSTAT 0xB0200040
++#define NUSBD_EP0WRSTAT 0xB0200044
++#define NUSBD_EP1WRSTAT 0xB0200048
++#define NUSBD_EP2WRSTAT 0xB020004C
++#define NUSBD_EP3RDSTAT 0xB0200050
++#define NUSBD_EP4RDSTAT 0xB0200054
++
++#define NUSBD_FRAMENUM 0xB0200038
++
++enum {
++ NDMA_ID_UART0_TX = 0,
++ NDMA_ID_UART0_RX,
++ NDMA_ID_GP04,
++ NDMA_ID_GP05,
++ NDMA_ID_AC97C_TX,
++ NDMA_ID_AC97C_RX,
++ NDMA_ID_UART3_TX,
++ NDMA_ID_UART3_RX,
++ NDMA_ID_USBDEV_EP0_RX,
++ NDMA_ID_USBDEV_EP0_TX,
++ NDMA_ID_USBDEV_EP1_TX,
++ NDMA_ID_USBDEV_EP2_TX,
++ NDMA_ID_USBDEV_EP3_RX,
++ NDMA_ID_USBDEV_EP4_RX,
++ NDMA_ID_I2S_TX,
++ NDMA_ID_I2S_RX,
++ NDMA_NUM_DEV
++};
++
++typedef struct ep_regs {
++ int rd;
++ int wr;
++ int cs;
++ int rds;
++ int wrs;
++ int rx_id;
++ int tx_id;
++ char * rx_str;
++ char * tx_str;
++ int indma;
++ int outdma;
++ int last;
++ int eptype;
++} ep_regs_t;
++
++#define MAX_EPN_PACKET_SIZE 64
++#define CP0_PRID_SOC_MASK 0xff000000
++#define CP0_PRID_AU1000 0x00000000
++#define CP0_PRID_AU1500 0x01000000
++#define CP0_PRID_AU1100 0x02000000
++#define CP0_PRID_REV_MASK 0x000000ff
++
+diff -Nru a/drivers/usbd/ep0.c b/drivers/usbd/ep0.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/ep0.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,565 @@
++/*
++ * usbd/ep0.c
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@lineo.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++/*
++ * This function driver implements support for all of the USB 2.0 Chapter
++ * nine requests.
++ *
++ * Any request that is not required by Chapter nine is passed to the other
++ * function drivers recv_setup routine.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++//EXPORT_NO_SYMBOLS;
++
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/list.h>
++#include <asm/uaccess.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++
++#include <linux/smp_lock.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/string.h>
++
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-func.h"
++#include "usbd-bus.h" // for usbd_recv_setup_irq() definition
++#include "usbd-admin.h"
++
++struct usb_function_instance * ep0_function;
++
++/* C.f. 9.4 Standard Requests and table 9.3
++ *
++ * Encode valid requests into a bitmap for each recipient type for
++ * both directions.
++ *
++ */
++
++#define STD(x) (1<<(x+1))
++
++/* h2d_standard_requests and d2h_standard_requests
++ *
++ * These tables list all of the valid Chapter Nine requests. Any request
++ * not listed in these tables will NOT be processed by the EP0 function and
++ * will instead be passed to the appropriate function driver.
++ */
++u32 h2d_standard_requests[4] = {
++ // 0 - Device
++ STD(USB_REQ_CLEAR_FEATURE) |
++ STD(USB_REQ_SET_FEATURE) |
++ STD(USB_REQ_SET_ADDRESS) |
++ STD(USB_REQ_SET_DESCRIPTOR) |
++ STD(USB_REQ_GET_CONFIGURATION) |
++ STD(USB_REQ_SET_CONFIGURATION) ,
++ // 1 - Interface
++ STD(USB_REQ_CLEAR_FEATURE) |
++ STD(USB_REQ_SET_FEATURE) |
++ STD(USB_REQ_SET_INTERFACE) ,
++ // 2 - Endpoint
++ STD(USB_REQ_CLEAR_FEATURE) |
++ STD(USB_REQ_SET_FEATURE) ,
++ // 3 - Other
++ 0,
++};
++
++u32 d2h_standard_requests[4] = {
++ // 0 - Device
++ STD(USB_REQ_GET_STATUS) |
++ STD(USB_REQ_GET_DESCRIPTOR) ,
++ // 1 - Interface
++ STD(USB_REQ_GET_STATUS) |
++ STD(USB_REQ_GET_INTERFACE) ,
++ // 2 - Endpoint
++ STD(USB_REQ_GET_STATUS) |
++ STD(USB_REQ_SYNCH_FRAME) ,
++ // 3 - Other
++ 0,
++};
++
++
++/* Endpoint ZEro Configuration *************************************************************** */
++
++/* ep0_event_irq - respond to USB event
++ *
++ * Process USB events.
++ */
++static void ep0_event_irq (struct usb_function_instance *function, usb_device_event_t event, int dummy )
++{
++ switch (event) {
++ case DEVICE_CREATE:
++ default:
++ break;
++ }
++}
++
++/* copy_config - copy data into urb buffer
++ */
++static int copy_config (u8 *cp, void *data, int actual_length, int max_buf)
++{
++ int available = max_buf - actual_length;
++ int length = MIN(*(u8 *)data, available);
++
++ RETURN_ZERO_IF (!length);
++ memcpy (cp, data, length);
++ return length;
++}
++
++/* copy_config - copy data into urb buffer
++ */
++static int copy_endpoint (struct usb_function_instance *function, u8 *cp,
++ struct usb_endpoint_descriptor *endpoint, int endpoint_index, int actual_length, int max_buf, int hs)
++{
++ int available = max_buf - actual_length;
++ int length = MIN(endpoint->bLength, available);
++ struct usb_endpoint_descriptor endpoint_copy;
++
++ RETURN_ZERO_IF (!length);
++ memcpy (&endpoint_copy, endpoint, endpoint->bLength);
++ usbd_endpoint_update(function, endpoint_index, &endpoint_copy, hs);
++ memcpy (cp, &endpoint_copy, length);
++ return length;
++}
++
++/* usbd_get_descriptor - copy descriptor into urb buffer
++ *
++ * Return non-zero for error.
++ */
++int usbd_get_descriptor (struct usb_bus_instance *bus, u8 *buffer, int max, int descriptor_type, int index)
++{
++ struct usb_function_driver *function_driver = bus->function_instance->function_driver;
++ int actual_length = 0;
++
++ switch (descriptor_type) {
++ case USB_DESCRIPTOR_TYPE_DEVICE:
++ {
++ struct usb_device_descriptor *device_descriptor = function_driver->device_descriptor;
++
++ // copy descriptor for this device
++ actual_length += copy_config (buffer + actual_length, device_descriptor, actual_length, max);
++
++ // correct the correct control endpoint 0 max packet size into the descriptor
++ device_descriptor = (struct usb_device_descriptor *) buffer;
++ device_descriptor->bMaxPacketSize0 = bus->driver->maxpacketsize;
++ }
++ break;
++
++#ifdef CONFIG_USBD_HIGH_SPEED
++ case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER: // c.f. 9.6.2 Device Qualifier
++ {
++ struct usb_device_qualifier_descriptor *device_qualifier_descriptor =
++ function_driver->device_qualifier_descriptor;
++
++ // copy descriptor for this device
++ actual_length += copy_config (buffer + actual_length, device_qualifier_descriptor, actual_length, max);
++
++ }
++ break;
++
++ case USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION:
++ case USB_DESCRIPTOR_TYPE_CONFIGURATION:
++ {
++ int hs = bus->HighSpeedFlag ? descriptor_type == USB_DESCRIPTOR_TYPE_CONFIGURATION:
++ descriptor_type == USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION;
++#else
++ case USB_DESCRIPTOR_TYPE_CONFIGURATION:
++ {
++ int hs = 0;
++#endif
++ int interface;
++
++ struct usb_configuration_instance *configuration_instance =
++ &function_driver->configuration_instance_array[index];
++
++ struct usb_configuration_descriptor *configuration_descriptor =
++ configuration_instance->configuration_descriptor;
++
++ RETURN_EINVAL_IF (!configuration_descriptor);
++ RETURN_EINVAL_IF (index > function_driver->device_descriptor->bNumConfigurations);
++
++ actual_length += copy_config (buffer + actual_length, configuration_descriptor, actual_length, max);
++
++ // iterate across bNumInterfaces for specified configuration
++ for (interface = 0; interface < configuration_descriptor->bNumInterfaces; interface++) {
++
++ int alternate;
++ struct usb_interface_instance *interface_instance =
++ configuration_instance->interface_instance_array + interface;
++
++ // iterate across interface alternates
++ for (alternate = 0; alternate < interface_instance->alternates; alternate++) {
++
++ int class;
++ int endpoint;
++
++ struct usb_alternate_instance *alternate_instance =
++ interface_instance->alternates_instance_array + alternate;
++
++ //struct usb_interface_descriptor *usb_interface_descriptor;
++
++ // copy descriptor for this interface
++ actual_length += copy_config (buffer + actual_length,
++ alternate_instance->interface_descriptor, actual_length, max);
++
++ // iterate across classes for this alternate interface
++ for (class = 0; class < alternate_instance->classes; class++)
++ actual_length += copy_config (buffer + actual_length,
++ *(alternate_instance->class_list + class), actual_length, max);
++
++ // iterate across endpoints for this alternate interface
++ //interface_descriptor = alternate_instance->interface_descriptor;
++
++ for (endpoint = 0; endpoint < alternate_instance->endpoints ; endpoint++) {
++
++ //printk(KERN_INFO"%s: endpoint: %d index: %d\n",
++ // __FUNCTION__, endpoint,
++ // alternate_instance->endpoint_indexes[endpoint]
++ // );
++ actual_length += copy_endpoint (bus->function_instance,
++ buffer + actual_length,
++ *(( alternate_instance->endpoint_list) + endpoint),
++ alternate_instance->endpoint_indexes[endpoint],
++ actual_length, max, hs);
++ }
++ }
++ }
++ }
++ break;
++
++ case USB_DESCRIPTOR_TYPE_STRING:
++ {
++ struct usb_string_descriptor *string_descriptor;
++ RETURN_EINVAL_IF (!(string_descriptor = usbd_get_string (index)));
++ actual_length += copy_config (buffer + actual_length, string_descriptor, actual_length, max);
++ }
++ break;
++
++ default:
++ return -EINVAL;
++ }
++ return actual_length;
++}
++
++/* ep0_recv_setup_irq - process a device request
++ *
++ * Process a received device request. If not a Chapter nine request pass it
++ * to the other loaded function driver recv_setup_irq() function.
++ *
++ * Return non-zero to indicate failure.
++ */
++static int ep0_recv_setup_irq (struct usb_device_request *request)
++{
++ struct usb_function_instance *function = ep0_function;
++ struct usb_bus_instance *bus = ep0_function->bus;
++
++#if 0
++ printk(KERN_INFO"%s: bus: %p bmRequestType:%02x bRequest:%02x wValue:%04x wIndex:%04x wLength:%04x %d\n", __FUNCTION__,
++ function->bus, request->bmRequestType, request->bRequest,
++ le16_to_cpu(request->wValue), le16_to_cpu(request->wIndex), le16_to_cpu(request->wLength),
++ request->bRequest);
++#endif
++
++ // handle USB Standard Request only (c.f. USB Spec table 9-2, D6..5 must be 0)
++
++ THROW_IF ((request->bmRequestType & USB_REQ_TYPE_MASK) != 0, non_standard);
++
++ THROW_IF(!( (request->bmRequestType & USB_DIR_IN ? d2h_standard_requests : h2d_standard_requests)
++ [request->bmRequestType & 0x3] & STD(request->bRequest)), non_standard );
++
++ CATCH(non_standard) {
++ return usbd_recv_setup_irq(bus->function_instance, request);
++ }
++
++ switch (bus->device_state) {
++ case STATE_CREATED:
++ case STATE_ATTACHED:
++ case STATE_POWERED:
++ return -EINVAL;
++
++ case STATE_INIT:
++ case STATE_DEFAULT:
++ switch (request->bRequest) {
++ case USB_REQ_GET_STATUS:
++ case USB_REQ_GET_INTERFACE:
++ case USB_REQ_SYNCH_FRAME:
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ case USB_REQ_SET_DESCRIPTOR:
++ case USB_REQ_SET_INTERFACE:
++ printk(KERN_INFO"%s: bad device_state\n", __FUNCTION__);
++ return -EINVAL;
++
++ case USB_REQ_SET_CONFIGURATION:
++ case USB_REQ_SET_ADDRESS:
++ case USB_REQ_GET_DESCRIPTOR:
++ case USB_REQ_GET_CONFIGURATION:
++ break;
++ }
++ case STATE_ADDRESSED:
++ case STATE_CONFIGURED:
++ case STATE_SUSPENDED:
++ break;
++ case STATE_UNKNOWN:
++ printk(KERN_INFO"%s: suspended or unknown\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ // handle all requests that return data (direction bit set on bm RequestType)
++ if ((request->bmRequestType & USB_REQ_DIRECTION_MASK)) {
++
++ struct urb *urb;
++ int rc = 0;
++ switch (request->bRequest) {
++ case USB_REQ_SYNCH_FRAME:
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ case USB_REQ_SET_ADDRESS:
++ case USB_REQ_SET_DESCRIPTOR:
++ case USB_REQ_SET_CONFIGURATION:
++ case USB_REQ_SET_INTERFACE:
++ printk(KERN_INFO"%s: bad direction\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ RETURN_EINVAL_IF(!le16_to_cpu(request->wLength));
++
++ // allocate urb, no callback, urb will be automatically de-allocated
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb (function, 0, le16_to_cpu(request->wLength), NULL)));
++
++ switch (request->bRequest) {
++
++ case USB_REQ_GET_STATUS:
++ urb->actual_length = 2;
++ urb->buffer[0] = urb->buffer[1] = 0;
++ switch (request->bmRequestType & USB_REQ_RECIPIENT_MASK) {
++ case USB_REQ_RECIPIENT_DEVICE:
++ urb->buffer[0] = USB_STATUS_SELFPOWERED;
++ break;
++ case USB_REQ_RECIPIENT_INTERFACE:
++ break;
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ urb->buffer[0] = usbd_endpoint_halted (function, le16_to_cpu(request->wIndex));
++ break;
++ case USB_REQ_RECIPIENT_OTHER:
++ urb->actual_length = 0;
++ default:
++ break;
++ }
++ rc = 0;
++
++ break;
++
++ case USB_REQ_GET_DESCRIPTOR:
++ rc = usbd_get_descriptor (bus, urb->buffer,
++ le16_to_cpu (request->wLength),
++ le16_to_cpu (request->wValue >> 8),
++ le16_to_cpu (request->wValue) & 0xff);
++ if (rc != -EINVAL) {
++ urb->actual_length = rc;
++ rc = 0;
++ }
++ break;
++
++ case USB_REQ_GET_CONFIGURATION:
++ urb->actual_length = 1;
++ urb->buffer[0] = bus->ConfigurationValue;
++ break;
++
++ case USB_REQ_GET_INTERFACE:
++ RETURN_EINVAL_IF(le16_to_cpu(request->wIndex) > bus->bNumInterfaces);
++ urb->actual_length = 1;
++ urb->buffer[0] = bus->alternates[le16_to_cpu(request->wIndex)];
++ break;
++ default:
++ rc = 1;
++ }
++
++ //printk(KERN_INFO"%s: actual: %d packetsize: %d wIndex: %d rc: %d\n", __FUNCTION__,
++ // urb->actual_length, urb->bus->driver->maxpacketsize, le16_to_cpu(request->wLength), rc);
++
++ if (!(urb->actual_length % urb->bus->driver->maxpacketsize) &&
++ (urb->actual_length < le16_to_cpu(request->wLength)))
++ {
++ //printk(KERN_INFO"%s: NEED ZLP\n", __FUNCTION__);
++ urb->flags |= USBD_URB_SENDZLP;
++ }
++ if (!rc)
++ RETURN_ZERO_IF(!usbd_send_urb(urb));
++ //printk(KERN_INFO"%s: failed urb: %p\n", __FUNCTION__, urb);
++ usbd_dealloc_urb(urb);
++ return -EINVAL;
++ }
++ // handle the requests that do not return data
++ else {
++
++ switch (request->bRequest) {
++
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ switch (request->bmRequestType & USB_REQ_RECIPIENT_MASK) {
++ case USB_REQ_RECIPIENT_DEVICE:
++ // XXX DEVICE_REMOTE_WAKEUP or TEST_MODE would be added here
++ // XXX fall through for now as we do not support either
++ case USB_REQ_RECIPIENT_INTERFACE:
++ case USB_REQ_RECIPIENT_OTHER:
++ default:
++ return -EINVAL;
++
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ if (le16_to_cpu(request->wValue) == USB_ENDPOINT_HALT)
++ return usbd_device_feature (function, le16_to_cpu (request->wIndex) & 0x7f,
++ request->bRequest == USB_REQ_SET_FEATURE);
++
++ else
++ return -EINVAL ;
++ }
++
++ case USB_REQ_SET_ADDRESS:
++ // check if this is a re-address, reset first if it is (this shouldn't be possible)
++ RETURN_EINVAL_IF (bus->device_state != STATE_DEFAULT);
++ usbd_bus_event (bus, DEVICE_ADDRESS_ASSIGNED, le16_to_cpu(request->wValue));
++ return 0;
++
++ case USB_REQ_SET_DESCRIPTOR:
++ // XXX should we support this?
++ // This would require allocating a rcv urb and using usbd_start_recv()
++ return -EINVAL;
++
++ case USB_REQ_SET_CONFIGURATION:
++ {
++ struct usb_function_driver *function_driver = bus->function_instance->function_driver;
++ int bNumConfigurations = function_driver->bNumConfigurations;
++ int bNumInterfaces;
++ u8 ConfigurationValue;
++
++
++ struct usb_configuration_instance *configuration_instance;
++ struct usb_configuration_descriptor *configuration_descriptor;
++
++ // get rid of previous interface and alternates
++ if (bus->bNumInterfaces && bus->alternates) {
++ bus->bNumInterfaces = 0;
++ lkfree(bus->alternates);
++ bus->alternates = NULL;
++ }
++
++ // c.f. 9.4.7 - the top half of wValue is reserved
++ //
++ // c.f. 9.4.7 - zero is the default or addressed state, in our case this
++ // is the same is configuration zero, but will be fixed in usbd.c when used.
++
++ ConfigurationValue = le16_to_cpu (request->wValue) & 0x7f;
++
++ RETURN_EINVAL_IF(ConfigurationValue > bNumConfigurations);
++
++ ConfigurationValue = ConfigurationValue ? 0 : ConfigurationValue -1;
++
++ configuration_instance = &function_driver->configuration_instance_array[ConfigurationValue];
++ configuration_descriptor = configuration_instance->configuration_descriptor;
++
++ RETURN_EINVAL_IF(!configuration_descriptor);
++
++ bNumInterfaces = configuration_instance->bNumInterfaces;
++
++ bus->ConfigurationValue = ConfigurationValue + 1;
++
++ // reset interface and alternate settings
++
++ RETURN_EINVAL_IF (!(bus->alternates = ckmalloc(bNumInterfaces, GFP_ATOMIC)));
++ bus->bNumInterfaces = bNumInterfaces;
++
++ //usbd_bus->device_event (bus, DEVICE_CONFIGURED, 0);
++ usbd_bus_event (bus, DEVICE_CONFIGURED, 0);
++ return 0;
++ }
++
++ case USB_REQ_SET_INTERFACE:
++ {
++ int interface = le16_to_cpu(request->wIndex);
++
++ RETURN_EINVAL_IF(interface > bus->bNumInterfaces);
++
++ bus->alternates[interface] = le16_to_cpu(request->wValue);
++ usbd_bus_event (bus, DEVICE_SET_INTERFACE, 0);
++ return 0;
++ }
++
++ case USB_REQ_GET_STATUS:
++ case USB_REQ_GET_DESCRIPTOR:
++ case USB_REQ_GET_CONFIGURATION:
++ case USB_REQ_GET_INTERFACE:
++ case USB_REQ_SYNCH_FRAME: // XXX should never see this (?)
++ printk(KERN_INFO"%s: unknown\n", __FUNCTION__);
++ return -EINVAL;
++ }
++ }
++ return -EINVAL;
++}
++
++
++/* ep0_function_enable - enable the endpoint zero function
++ *
++ * Return non-zero on failure.
++ */
++static int ep0_function_enable (struct usb_function_instance *function)
++{
++ ep0_function = function;
++ return 0;
++}
++
++/* ep0_function_disable - disable the endpoint zero function
++ */
++static void ep0_function_disable (struct usb_function_instance *function)
++{
++ ep0_function = NULL;
++}
++
++
++static struct usb_function_operations ep0_ops = {
++ event_irq: ep0_event_irq,
++ recv_setup_irq: ep0_recv_setup_irq,
++ function_enable: ep0_function_enable,
++ function_disable: ep0_function_disable,
++};
++
++struct usb_function_driver ep0_driver = {
++ name: "EP0",
++ fops: &ep0_ops,
++};
++
++EXPORT_SYMBOL(usbd_get_descriptor);
+diff -Nru a/drivers/usbd/mouse_fd/Config.in b/drivers/usbd/mouse_fd/Config.in
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/mouse_fd/Config.in Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,26 @@
++#
++# Mouse Function Driver
++#
++# Copyright (C) 2003 Belcarra
++#
++
++
++mainmenu_option next_comment
++
++comment "Random Mouse Function"
++dep_tristate ' Mouse Function' CONFIG_USBD_MOUSE $CONFIG_USBD
++
++if [ "$CONFIG_USBD_MOUSE" = "y" -o "$CONFIG_USBD_MOUSE" = "m" ]; then
++ hex 'VendorID (hex value)' CONFIG_USBD_MOUSE_VENDORID "12b9"
++ hex 'ProductID (hex value)' CONFIG_USBD_MOUSE_PRODUCTID "f003"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_USBD_MOUSE_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_USBD_MOUSE_MANUFACTURER "Belcarra"
++ #string 'iProduct (string)' CONFIG_USBD_MOUSE_PRODUCT_NAME "Belcarra Mouse"
++
++ string 'iConfiguration (string)' CONFIG_USBD_MOUSE_DESC "Acm Cfg"
++ string 'Comm Interface iInterface (string)' CONFIG_USBD_MOUSE_COMM_INTF "Comm Intf"
++ bool 'Mouse BH Test' CONFIG_USBD_MOUSE_BH
++
++fi
++endmenu
+diff -Nru a/drivers/usbd/mouse_fd/Makefile b/drivers/usbd/mouse_fd/Makefile
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/mouse_fd/Makefile Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,66 @@
++#
++# Function driver for a Mouse USB Device
++#
++# Copyright (c) 2003 Belcarra
++
++# Multipart objects.
++
++O_TARGET := mouse_fd.o
++list-multi := mouse_fd.o
++
++mouse_fd-objs := mouse.o
++
++# Objects that export symbols.
++export-objs := mouse.o
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_USBD_MOUSE) += mouse_fd.o
++
++# Extract lists of the multi-part drivers.
++# The 'int-*' lists are the intermediate files used to build the multi's.
++
++multi-y := $(filter $(list-multi), $(obj-y))
++multi-m := $(filter $(list-multi), $(obj-m))
++int-y := $(sort $(foreach m, $(multi-y), $($(basename $(m))-objs)))
++int-m := $(sort $(foreach m, $(multi-m), $($(basename $(m))-objs)))
++
++# Files that are both resident and modular: remove from modular.
++
++obj-m := $(filter-out $(obj-y), $(obj-m))
++int-m := $(filter-out $(int-y), $(int-m))
++
++# Translate to Rules.make lists.
++
++O_OBJS := $(filter-out $(export-objs), $(obj-y))
++OX_OBJS := $(filter $(export-objs), $(obj-y))
++M_OBJS := $(sort $(filter-out $(export-objs), $(obj-m)))
++MX_OBJS := $(sort $(filter $(export-objs), $(obj-m)))
++MI_OBJS := $(sort $(filter-out $(export-objs), $(int-m)))
++MIX_OBJS := $(sort $(filter $(export-objs), $(int-m)))
++
++# The global Rules.make.
++
++USBD=$(TOPDIR)/drivers/usbd
++MOUSED=$(USBD)/mouse_fd
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -I$(MOUSED) -I$(USBD) -Wno-unused -Wno-format
++EXTRA_CFLAGS_nostdinc += -I$(MOUSED) -I$(USBD) -Wno-unused -Wno-format
++
++# Link rules for multi-part drivers.
++
++mouse_fd.o: $(mouse_fd-objs)
++ $(LD) -r -o $@ $(mouse_fd-objs)
++
++# dependencies:
++
++mouse.o: $(USBD)/usbd.h $(USBD)/usbd-bus.h $(USBD)/usbd-func.h
++
++
+diff -Nru a/drivers/usbd/mouse_fd/getmouse.c b/drivers/usbd/mouse_fd/getmouse.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/mouse_fd/getmouse.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,122 @@
++/*******************************************************************************
++ * File: FILE
++ * Module: MODULE
++ * Author: AUTHOR
++ * Date: DATE
++ *
++ * Notes:
++ *
++ * $Id$
++ *
++ * History:
++ * $Log$
++ *
++ ******************************************************************************/
++
++/*
++ *
++ *
++ * 3.2. Non-Canonical Input Processing
++ *
++ * In non-canonical input processing mode, input is not assembled into lines and
++ * input processing (erase, kill, delete, etc.) does not occur. Two parameters
++ * control the behavior of this mode: c_cc[VTIME] sets the character timer, and
++ * c_cc[VMIN] sets the minimum number of characters to receive before satisfying
++ * the read.
++ *
++ * If MIN > 0 and TIME = 0, MIN sets the number of characters to receive before
++ * the read is satisfied. As TIME is zero, the timer is not used.
++ *
++ * If MIN = 0 and TIME > 0, TIME serves as a timeout value. The read will be
++ * satisfied if a single character is read, or TIME is exceeded (t = TIME *0.1
++ * s). If TIME is exceeded, no character will be returned.
++ *
++ * If MIN > 0 and TIME > 0, TIME serves as an inter-character timer. The read
++ * will be satisfied if MIN characters are received, or the time between two
++ * characters exceeds TIME. The timer is restarted every time a character is
++ * received and only becomes active after the first character has been received.
++ *
++ * If MIN = 0 and TIME = 0, read will be satisfied immediately. The number of
++ * characters currently available, or the number of characters requested will be
++ * returned. According to Antonino (see contributions), you could issue a fcntl
++ * (fd, F_SETFL, FNDELAY); before reading to get the same result.
++ *
++ * By modifying newtio.c_cc[VTIME] and newtio.c_cc[VMIN] all modes described
++ * above can be tested.
++ *
++ */
++
++#include <sys/types.h>
++#include <sys/stat.h>
++#include <fcntl.h>
++#include <termios.h>
++#include <stdio.h>
++
++#define BAUDRATE B1200
++#define MODEMDEVICE "/dev/ttyS0"
++#define _POSIX_SOURCE 1 /* POSIX compliant source */
++#define FALSE 0
++#define TRUE 1
++
++volatile int STOP=FALSE;
++
++main()
++{
++ int fd,c, res;
++ struct termios oldtio,newtio;
++ unsigned char buf[255];
++
++ int bytes;
++ unsigned char mouse[3];
++
++ fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY );
++ if (fd <0) {perror(MODEMDEVICE); exit(-1); }
++
++ tcgetattr(fd,&oldtio); /* save current port settings */
++
++ bzero(&newtio, sizeof(newtio));
++ newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
++ newtio.c_iflag = IGNPAR;
++ newtio.c_oflag = 0;
++
++ /* set input mode (non-canonical, no echo,...) */
++ newtio.c_lflag = 0;
++
++ newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
++ newtio.c_cc[VMIN] = 1; /* blocking read until 5 chars received */
++
++ tcflush(fd, TCIFLUSH);
++ tcsetattr(fd,TCSANOW,&newtio);
++
++
++ bytes = 0;
++ while (STOP==FALSE) { /* loop for input */
++ unsigned char c;
++
++ res = read(fd,buf,1); /* returns after 5 chars have been input */
++ buf[res]=0; /* so we can printf... */
++ //fprintf(stderr, ":%02x:%d\n", buf[0], res);
++ //if (buf[0]=='z') STOP=TRUE;
++
++ c = buf[0];
++
++ if ( c & 0x40 ) {
++ bytes = 1;
++ mouse[0] = c;
++ }
++ else if (bytes == 1) {
++ bytes = 2;
++ mouse[1] = c;
++ }
++ else if (bytes == 2) {
++ bytes = 0;
++ mouse[2] = c;
++ fprintf(stderr, "%02x %02x %02x\n", mouse[0], mouse[1], mouse[2]);
++ //printf("%c%c%c", mouse[0], mouse[1], mouse[2]);
++ }
++ }
++ tcsetattr(fd,TCSANOW,&oldtio);
++}
++
++
++/* End of FILE */
+diff -Nru a/drivers/usbd/mouse_fd/mouse.c b/drivers/usbd/mouse_fd/mouse.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/mouse_fd/mouse.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,548 @@
++/*
++ * usbd/mouse_fd/mouse.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This is a test USB HID Function Driver designed to test and
++ * verify that INTERRUPT IN endpoints work properly.
++ *
++ * This emulates a simple USB mouse and generates a constant stream
++ * of small random mouse movements.
++ *
++ * To use simply load with something like:
++ *
++ * insmod mouse_fd.o vendor_id=0xffff product_id=0xffff
++ *
++ * And attach to a Windows box. Windows should recognize as a mouse and
++ * immediately start receiving a stream of data.
++ *
++ * To terminate simply unplug.
++ *
++ * The mouse driver has several other characteristics to allow testing of
++ * other features of the bus interface driver:
++ *
++ * - ep0 ZLP handling
++ *
++ * - ep0 delayed CONTROL READ
++ *
++ *
++ * Notes
++ *
++ * 1. The mouse driver is product name is hard coded to a string that will
++ * generate a string descriptor that is 32 bytes long. This will test
++ * most UDC's ep0 ZLP handling as it is a multiple of the most common
++ * UDC endpoint zero size. (An option can be added later to allow for
++ * 64 byte ep0 packetsize.)
++ *
++ * 2. The CONFIG_USBD_MOUSE_BH option can be enabled to delay the HID report
++ * to being generated by a bottom half handler. This will verify that
++ * the bus interface driver properly handles the case of a delayed
++ * CONTROL READ. I.e. when the usbd_recv_setup_irq() function returns
++ * zero for successful completion but there is no tx_urb containing the
++ * requested data. The bus interface driver must setup the conditions for
++ * ACK'ing the SETUP packet but then NAK the IN data for endpoint zero
++ * until the tx_urb is started later.
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_LICENSE("PROPRIETARY");
++MODULE_DESCRIPTION ("Belcarra Random Walk MOUSE Function");
++
++#include <linux/init.h>
++#include <asm/uaccess.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/interrupt.h>
++#include <asm/atomic.h>
++#include <linux/random.h>
++#include <linux/slab.h>
++
++#include "usbd-chap9.h"
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++USBD_MODULE_INFO ("mouse_fd 2.0-beta");
++
++/* Module Parameters ************************************************************************* */
++
++static u32 vendor_id;
++static u32 product_id;
++
++MODULE_PARM (vendor_id, "i");
++MODULE_PARM (product_id, "i");
++
++MODULE_PARM_DESC (vendor_id, "Device Vendor ID");
++MODULE_PARM_DESC (product_id, "Device Product ID");
++
++/*
++ * ep0 testing.... ensure that this is exactly 16 bytes
++ */
++#undef CONFIG_USBD_MOUSE_PRODUCT_NAME
++#define CONFIG_USBD_MOUSE_PRODUCT_NAME "Belcarra Mouse"
++
++/*
++ * MOUSE Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++#define BULK_INT 0x00
++#define ENDPOINTS 0x01
++
++char MouseHIDReport[52] = {
++ 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
++ 0x09, 0x02, // USAGE (Mouse)
++ 0xa1, 0x01, // COLLECTION (Application)
++ 0x09, 0x01, // USAGE (Pointer)
++ 0xa1, 0x00, // COLLECTION (Physical)
++ 0x05, 0x09, // USAGE_PAGE (Button)
++ 0x19, 0x01, // USAGE_MINIMUM (Button 1)
++ 0x29, 0x03, // USAGE_MAXIMUM (Button 3)
++ 0x15, 0x00, // LOGICAL_MINIMUM (0)
++ 0x25, 0x01, // LOGICAL_MAXIMUM (1)
++ 0x95, 0x03, // REPORT_COUNT (3)
++ 0x75, 0x01, // REPORT_SIZE (1)
++ 0x81, 0x02, // INPUT (Data,Var,Abs)
++ 0x95, 0x01, // REPORT_COUNT (1)
++ 0x75, 0x05, // REPORT_SIZE (5)
++ 0x81, 0x03, // INPUT (Cnst,Var,Abs)
++ 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
++ 0x09, 0x30, // USAGE (X)
++ 0x09, 0x31, // USAGE (Y)
++ 0x09, 0x38, // USAGE (WHEEL)
++ 0x15, 0x81, // LOGICAL_MINIMUM (-127)
++ 0x25, 0x7f, // LOGICAL_MAXIMUM (127)
++ 0x75, 0x08, // REPORT_SIZE (8)
++ 0x95, 0x03, // REPORT_COUNT (3)
++ 0x81, 0x06, // INPUT (Data,Var,Rel)
++ 0xc0, // END_COLLECTION
++ 0xc0 // END_COLLECTION
++};
++
++struct usb_endpoint_descriptor mouse_data = {
++ bLength: 0x07,
++ bDescriptorType: USB_DT_ENDPOINT,
++ bEndpointAddress: IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: __constant_cpu_to_le16(0x10),
++ bInterval: 0x01,
++};
++
++struct hid_descriptor mouse_hid = {
++ bLength: 0x09,
++ bDescriptorType: 0x21,
++ bcdHID: __constant_cpu_to_le16(0x110),
++ bCountryCode: 0x00,
++ bNumDescriptors: 0x01,
++ bReportType: 0x22,
++ wItemLength: __constant_cpu_to_le16(0x34),
++};
++
++static struct usb_endpoint_descriptor *mouse_default[] = { &mouse_data, };
++u8 mouse_indexes[] = { BULK_INT, };
++static struct usb_generic_class_descriptor *mouse_hid_descriptors[] = { (struct usb_generic_class_descriptor *)&mouse_hid, };
++
++/* Data Interface Alternate description(s)
++ */
++static __u8 mouse_data_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (mouse_default) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ 0x03, 0x01, 0x02, 0x00,
++};
++
++static struct usb_alternate_description mouse_data_alternate_descriptions[] = {
++ { iInterface:"Simple Mouse Interface - Interrupt",
++ interface_descriptor: (struct usb_interface_descriptor *)&mouse_data_alternate_descriptor,
++ classes:sizeof (mouse_hid_descriptors) / sizeof (struct usb_generic_class_descriptor *),
++ class_list: mouse_hid_descriptors,
++ endpoints:sizeof (mouse_default) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: mouse_default,
++ endpoint_indexes: mouse_indexes,
++ },
++};
++
++/* Interface description(s)
++ */
++static struct usb_interface_description mouse_interfaces[] = {
++ { alternates:sizeof (mouse_data_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:mouse_data_alternate_descriptions,},
++};
++
++
++/* Configuration description(s)
++ */
++static __u8 mouse_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, // wLength
++ sizeof (mouse_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ BMATTRIBUTE, BMAXPOWER,
++};
++
++struct usb_configuration_description mouse_description[] = {
++ { configuration_descriptor: (struct usb_configuration_descriptor *)mouse_configuration_descriptor,
++ iConfiguration:"USB Simple Serial Configuration",
++ bNumInterfaces:sizeof (mouse_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:mouse_interfaces,},
++};
++
++/* Device Description
++ */
++static struct usb_device_descriptor mouse_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: 0x00,
++ bDeviceSubClass: 0x00,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_MOUSE_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_MOUSE_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_MOUSE_BCDDEVICE),
++};
++
++static struct usb_endpoint_request mouse_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT, 16, 64, },
++ { 0, },
++};
++
++
++struct usb_device_description mouse_device_description = {
++ device_descriptor: &mouse_device_descriptor,
++ iManufacturer: CONFIG_USBD_MOUSE_MANUFACTURER,
++ iProduct: CONFIG_USBD_MOUSE_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: mouse_endpoint_requests,
++};
++
++
++/* MOUSE ***************************************************************************************** */
++
++struct mouse_private {
++ struct usb_function_instance *function;
++ struct tq_struct notification_bh;
++ int usb_driver_registered; // non-zero if usb function registered
++ unsigned char connected; // non-zero if connected to host (configured)
++ unsigned int writesize; // packetsize * 4
++ struct urb *tx_urb;
++ int wLength;
++ int x;
++ int y;
++ int last_x;
++ int last_y;
++ int n;
++};
++
++struct mouse_private mouse_private;
++
++
++/* Transmit Function *************************************************************************** */
++
++int get_xy[8] = {
++ 0, 0, 1, 1,
++ 0, 0, -1, -1,
++};
++
++void mouse_send(struct usb_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++ int new_x = 0;
++ int new_y = 0;
++ u8 random;
++
++ memset(mouse->tx_urb->buffer, 0, 4);
++ if (!mouse->n) {
++
++ get_random_bytes(&random, 1);
++
++ mouse->last_x = MAX(-4, MIN(4, mouse->last_x + get_xy[random & 0x7]));
++ mouse->last_y = MAX(-4, MIN(4, mouse->last_y + get_xy[(random >> 3) & 0x7]));
++ mouse->n = (random>>6) & 0x3;
++
++ new_x = mouse->x + mouse->last_x;
++ new_y = mouse->y + mouse->last_y;
++
++ mouse->tx_urb->buffer[1] = mouse->last_x;
++ mouse->x = new_x;
++ mouse->tx_urb->buffer[2] = mouse->last_y;
++ mouse->y = new_y;
++ mouse->tx_urb->actual_length = 4;
++#if 0
++ printk(KERN_INFO"%s: x: %4d y: %4d rand: %02x x: %2d y: %2d new_x: %4d new_y: %4d urb: %02x %02x %02x %02x\n",
++ __FUNCTION__,
++ mouse->x, mouse->y, random, x, y, new_x, new_y,
++ mouse->tx_urb->buffer[0], mouse->tx_urb->buffer[1],
++ mouse->tx_urb->buffer[2], mouse->tx_urb->buffer[3] );
++#endif
++ }
++ else if ((mouse->n)&1) {
++ mouse->n--;
++ }
++ else {
++ mouse->n--;
++ mouse->tx_urb->buffer[1] = mouse->last_x;
++ mouse->x = new_x;
++ mouse->tx_urb->buffer[2] = mouse->last_y;
++ mouse->y = new_y;
++ }
++ usbd_send_urb(mouse->tx_urb);
++}
++
++/* mouse_urb_sent - called to indicate URB transmit finished
++ * @urb: pointer to struct urb
++ * @rc: result
++ */
++int mouse_urb_sent (struct urb *urb, int rc)
++{
++ struct mouse_private *mouse = &mouse_private;
++ struct usb_function_instance *function = mouse->function;
++
++ RETURN_ZERO_IF(usbd_bus_status(function) == USBD_CLOSING);
++ RETURN_ZERO_IF(usbd_bus_status(function) != USBD_OK);
++ RETURN_ZERO_IF(usbd_device_state(function) != STATE_CONFIGURED);
++
++ mouse_send(function); // re-send
++ return 0;
++}
++
++/* USB Device Functions ************************************************************************ */
++
++/* mouse_event_irq - process a device event
++ *
++ */
++void mouse_event_irq (struct usb_function_instance *function, usb_device_event_t event, int data)
++{
++ struct mouse_private *mouse = &mouse_private;
++
++ switch (event) {
++ case DEVICE_CONFIGURED:
++ mouse->connected = 1;
++ if (!(mouse->tx_urb = usbd_alloc_urb (function, BULK_INT, 4, mouse_urb_sent)))
++ printk(KERN_INFO"%s: alloc failed\n", __FUNCTION__);
++ mouse_send(function); // start sending
++ break;
++
++ case DEVICE_RESET:
++ case DEVICE_DE_CONFIGURED:
++ BREAK_IF(!mouse->connected);
++ mouse->connected = 0;
++ if (mouse->tx_urb) {
++ usbd_dealloc_urb (mouse->tx_urb);
++ mouse->tx_urb = NULL;
++ }
++ break;
++ default:
++ break;
++ }
++}
++
++/* copy_config
++ * @urb: pointer to urb
++ * @data: pointer to configuration data
++ * @length: length of data
++ *
++ * Copy configuration data to urb transfer buffer if there is room for it.
++ */
++static int copy_report (struct urb *urb, void *data, int size, int max_buf)
++{
++ int available;
++ int length;
++
++ RETURN_EINVAL_IF (!urb);
++ RETURN_EINVAL_IF (!data);
++ RETURN_EINVAL_IF (!(length = size));
++ RETURN_EINVAL_IF ((available = max_buf - urb->actual_length) <= 0);
++
++ length = (length < available) ? length : available;
++ memcpy (urb->buffer + urb->actual_length, data, length);
++ urb->actual_length += length;
++ return 0;
++}
++
++/* mouse_send_hid - send an EP0 urb containing HID report
++ */
++static int mouse_send_hid (void *data)
++{
++ struct mouse_private *mouse = &mouse_private;
++ struct usb_function_instance *function = mouse->function;
++ struct urb *urb = usbd_alloc_urb_ep0(function, mouse->wLength, NULL);
++ RETURN_EINVAL_IF (copy_report(urb, MouseHIDReport, sizeof(MouseHIDReport), mouse->wLength));
++ RETURN_ZERO_IF(!usbd_send_urb(urb));
++ usbd_dealloc_urb(urb);
++ return -EINVAL;
++}
++
++#ifdef CONFIG_USBD_MOUSE_BH
++/* mouse_hid_bh - Bottom half handler to send a HID report
++ */
++static void mouse_hid_bh (void *data)
++{
++ struct usb_function_instance *function = mouse_private.function;
++ mouse_send_hid(function);
++ MOD_DEC_USE_COUNT;
++}
++
++/* mouse_schedule_bh - schedule a call for mouse_hid_bh
++ */
++static int mouse_schedule_bh (void)
++{
++ MOD_INC_USE_COUNT;
++ if (!schedule_task (&mouse_private.notification_bh)) {
++ MOD_DEC_USE_COUNT;
++ return -EINVAL;
++ }
++ return 0;
++}
++#endif /* CONFIG_USBD_MOUSE_BH */
++
++
++
++/* mouse_recv_setup_irq - called to indicate urb has been received
++ */
++int mouse_recv_setup_irq (struct usb_device_request *request)
++{
++ struct usb_function_instance *function = mouse_private.function;
++
++ /* verify that this is a usb class request per cdc-mouse specification or a vendor request.
++ * determine the request direction and process accordingly
++ */
++ switch (request->bmRequestType & (USB_REQ_DIRECTION_MASK | USB_REQ_TYPE_MASK)) {
++
++ case USB_REQ_HOST2DEVICE:
++ case USB_REQ_HOST2DEVICE | USB_REQ_TYPE_CLASS:
++ case USB_REQ_HOST2DEVICE | USB_REQ_TYPE_VENDOR:
++ return 0;
++
++ case USB_REQ_DEVICE2HOST :
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_CLASS:
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_VENDOR:
++
++ switch (request->bRequest) {
++ case USB_REQ_GET_DESCRIPTOR:
++ switch (le16_to_cpu(request->wValue)>>8) {
++ case HID_REPORT:
++ mouse_private.wLength = request->wLength;
++#ifdef CONFIG_USBD_MOUSE_BH
++ return mouse_schedule_bh();
++#else
++ return mouse_send_hid(function);
++#endif
++ }
++ default: break;
++ }
++ break;
++
++ default:
++ break;
++ }
++ return -EINVAL;
++}
++
++
++static int mouse_function_enable (struct usb_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++
++ MOD_INC_USE_COUNT;
++ mouse->function = function;
++ mouse->n = 0;
++ mouse->x = 0;
++ mouse->y = 0;
++ mouse->last_x = 0;
++ mouse->last_y = 0;
++
++ mouse->writesize = usbd_endpoint_wMaxPacketSize(function, BULK_INT, 0);
++
++ return 0;
++}
++
++static void mouse_function_disable (struct usb_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++ mouse->function = NULL;
++ mouse->writesize = 0;
++ mouse->function = NULL;
++ MOD_DEC_USE_COUNT;
++}
++
++static struct usb_function_operations function_ops = {
++ event_irq: mouse_event_irq,
++ recv_setup_irq: mouse_recv_setup_irq,
++ function_enable: mouse_function_enable,
++ function_disable: mouse_function_disable,
++};
++
++static struct usb_function_driver function_driver = {
++ name:"mouse-random",
++ fops:&function_ops,
++ device_description:&mouse_device_description,
++ bNumConfigurations:sizeof (mouse_description) / sizeof (struct usb_configuration_description),
++ configuration_description:mouse_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_MOUSE_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_MOUSE_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_MOUSE_BCDDEVICE),
++};
++
++
++/* USB Module init/exit ************************************************************************ */
++/*
++ * mouse_modinit - module init
++ *
++ */
++static int mouse_modinit (void)
++{
++ printk (KERN_INFO "%s: %s vendor_id: %04x product_id: %04x\n", __FUNCTION__, __usbd_module_info, vendor_id, product_id);
++
++ if (vendor_id)
++ function_driver.idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ function_driver.idProduct = cpu_to_le16(product_id);
++
++ mouse_hid.wItemLength = cpu_to_le16(0x34); // XXX mips compiler bug.....
++
++ // register as usb function driver
++ THROW_IF (usbd_register_function (&function_driver), error);
++ mouse_private.usb_driver_registered++;
++#ifdef CONFIG_USBD_MOUSE_BH
++ mouse_private.notification_bh.routine = mouse_hid_bh;
++ mouse_private.notification_bh.data = NULL;
++#endif
++ CATCH(error) {
++ if (mouse_private.usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ mouse_private.usb_driver_registered = 0;
++ }
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/* mouse_modexit - module cleanup
++ */
++static void mouse_modexit (void)
++{
++ if (mouse_private.usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ }
++}
++
++
++module_init (mouse_modinit);
++module_exit (mouse_modexit);
+diff -Nru a/drivers/usbd/network_fd/Config.in b/drivers/usbd/network_fd/Config.in
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/Config.in Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,97 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++comment "Network Function"
++
++dep_tristate ' Network Function Driver' CONFIG_USBD_NETWORK $CONFIG_USBD
++
++if [ "$CONFIG_USBD_NETWORK" = "y" -o "$CONFIG_USBD_NETWORK" = "m" ]; then
++
++ hex 'VendorID (hex value)' CONFIG_USBD_NETWORK_VENDORID "12b9"
++ hex 'ProductID (hex value)' CONFIG_USBD_NETWORK_PRODUCTID "f001"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_USBD_NETWORK_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_USBD_NETWORK_MANUFACTURER "Belcarra"
++ string 'iProduct (string)' CONFIG_USBD_NETWORK_PRODUCT_NAME "Belcarra BLAN Device"
++
++
++ comment ''
++ bool " MDLM-BLAN Networking mode (Personal Devices)" CONFIG_USBD_NETWORK_BLAN
++ if [ "$CONFIG_USBD_NETWORK_BLAN" = "y" ]; then
++ string ' iConfiguration (string)' CONFIG_USBD_NETWORK_BLAN_DESC "BLAN Net Cfg"
++ string ' iInterface (string)' CONFIG_USBD_NETWORK_BLAN_INTF "Comm/Data Intf"
++ fi
++
++ if [ "$CONFIG_USBD_NETWORK_BLAN" = "y" ]; then
++ bool " CRC" CONFIG_USBD_NETWORK_BLAN_CRC
++
++ if [ "$CONFIG_USBD_NETWORK_BLAN_CRC" = "y" ]; then
++
++ bool " Pad Before CRC (to wMaxPacketSize-1)" CONFIG_USBD_NETWORK_BLAN_PADBEFORE
++ bool " Pad After CRC" CONFIG_USBD_NETWORK_BLAN_PADAFTER
++ if [ "$CONFIG_USBD_NETWORK_BLAN" = "y" -a "$CONFIG_USBD_NETWORK_BLAN_PADAFTER" = "y" ]; then
++ int ' Pad multiple' CONFIG_USBD_NETWORK_BLAN_PADBYTES "8"
++ fi
++ bool " Fermat Randomizer" CONFIG_USBD_NETWORK_BLAN_FERMAT
++ fi
++ bool " Do not Set Time" CONFIG_USBD_NETWORK_BLAN_DO_NOT_SETTIME
++ bool " Request Hostname" CONFIG_USBD_NETWORK_BLAN_HOSTNAME
++ bool " Infrastructure Device" CONFIG_USBD_NETWORK_BLAN_NOBRIDGE
++ comment ''
++ fi
++
++ bool " MDLM-SAFE Networking mode (Bridge/Routers)" CONFIG_USBD_NETWORK_SAFE
++ if [ "$CONFIG_USBD_NETWORK_SAFE" = "y" ]; then
++ string ' Data Interface iConfiguration (string)' CONFIG_USBD_NETWORK_SAFE_DESC "SAFE Net Cfg"
++ string ' Data Interface iInterface (string)' CONFIG_USBD_NETWORK_SAFE_INTF "Data Intf"
++ fi
++
++
++ if [ "$CONFIG_USBD_NETWORK_SAFE" = "y" ]; then
++ bool " Do not Set Time" CONFIG_USBD_NETWORK_SAFE_DO_NOT_SETTIME
++ bool " CRC" CONFIG_USBD_NETWORK_SAFE_CRC
++ if [ "$CONFIG_USBD_NETWORK_SAFE_CRC" = "y" ]; then
++ bool " Pad Before CRC (to wMaxPacketSize-1)" CONFIG_USBD_NETWORK_SAFE_PADBEFORE
++ fi
++ bool " Infrastructure Device" CONFIG_USBD_NETWORK_SAFE_NOBRIDGE
++ comment ''
++ fi
++
++ bool " CDC Networking mode (Bridge/Routers)" CONFIG_USBD_NETWORK_CDC
++ if [ "$CONFIG_USBD_NETWORK_CDC" = "y" ]; then
++ string ' iConfiguration (string)' CONFIG_USBD_NETWORK_CDC_DESC "SAFE Net Cfg"
++ string ' Data Interface iInterface (string)' CONFIG_USBD_NETWORK_CDC_COMM_INTF "Comm Intf"
++ string ' Data (diabled) iInterface (string)' CONFIG_USBD_NETWORK_CDC_NODATA_INTF "Data (Disabled) Intf"
++ string ' Comm Interface iInterface (string)' CONFIG_USBD_NETWORK_CDC_DATA_INTF "Dat Intf"
++ fi
++
++ if [ "$CONFIG_USBD_NETWORK_SAFE" = "y" -a "$CONFIG_USBD_NETWORK_CDC" = "y" ]; then
++ comment 'Warning: CDC and MDLM-SAFE not allowed'
++ fi
++
++
++ bool " Failsafe BASIC Networking mode" CONFIG_USBD_NETWORK_BASIC
++ if [ "$CONFIG_USBD_NETWORK_BASIC" = "y" ]; then
++ string ' Data Interface iConfiguration (string)' CONFIG_USBD_NETWORK_BASIC_DESC "BASIC Net Cfg"
++ string ' Data Interface iInterface (string)' CONFIG_USBD_NETWORK_BASIC_INTF "Data Intf"
++ fi
++
++ bool " Failsafe BASIC2 Networking mode" CONFIG_USBD_NETWORK_BASIC2
++ if [ "$CONFIG_USBD_NETWORK_BASIC2" = "y" ]; then
++ string ' Data Interface iConfiguration (string)' CONFIG_USBD_NETWORK_BASIC2_DESC "BASIC Net Cfg"
++ string ' Comm Interface iInterface (string)' CONFIG_USBD_NETWORK_BASIC2_COMM_INTF "Comm Intf"
++ string ' Data Interface iInterface (string)' CONFIG_USBD_NETWORK_BASIC2_DATA_INTF "Data Intf"
++ fi
++
++
++ comment ''
++ bool ' Start Single Urb Test' CONFIG_USBD_NETWORK_START_SINGLE
++ bool ' EP0 Test' CONFIG_USBD_NETWORK_EP0TEST
++
++fi
++
++endmenu
+diff -Nru a/drivers/usbd/network_fd/Makefile b/drivers/usbd/network_fd/Makefile
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/Makefile Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,66 @@
++#
++# Network Function Driver
++#
++# Copyright (C) 2002-2003 Belcarra
++
++
++O_TARGET := network_fd.o
++list-multi := network_fd.o
++
++network_fd-objs := network.o basic.o basic2.o blan.o cdc.o safe.o fermat.o
++
++# Objects that export symbols.
++export-objs := network.o
++
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_USBD_NETWORK) += network_fd.o
++
++# Extract lists of the multi-part drivers.
++# The 'int-*' lists are the intermediate files used to build the multi's.
++
++multi-y := $(filter $(list-multi), $(obj-y))
++multi-m := $(filter $(list-multi), $(obj-m))
++int-y := $(sort $(foreach m, $(multi-y), $($(basename $(m))-objs)))
++int-m := $(sort $(foreach m, $(multi-m), $($(basename $(m))-objs)))
++
++# Files that are both resident and modular: remove from modular.
++
++obj-m := $(filter-out $(obj-y), $(obj-m))
++int-m := $(filter-out $(int-y), $(int-m))
++
++# Translate to Rules.make lists.
++
++O_OBJS := $(filter-out $(export-objs), $(obj-y))
++OX_OBJS := $(filter $(export-objs), $(obj-y))
++M_OBJS := $(sort $(filter-out $(export-objs), $(obj-m)))
++MX_OBJS := $(sort $(filter $(export-objs), $(obj-m)))
++MI_OBJS := $(sort $(filter-out $(export-objs), $(int-m)))
++MIX_OBJS := $(sort $(filter $(export-objs), $(int-m)))
++
++# The global Rules.make.
++
++USBD=$(TOPDIR)/drivers/usbd
++NETWORKD=$(USBD)/network_fd
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -I$(NETWORKD) -I$(USBD) -Wno-unused -Wno-format
++EXTRA_CFLAGS_nostdinc += -I$(NETWORKD) -I$(USBD) -Wno-unused -Wno-format
++
++# Link rules for multi-part drivers.
++
++network_fd.o: $(network_fd-objs)
++ $(LD) -r -o $@ $(network_fd-objs)
++
++# dependencies:
++
++network.o: network.h $(USBD)/usbd.h $(USBD)/usbd-bus.h $(USBD)/usbd-func.h
++
++
+diff -Nru a/drivers/usbd/network_fd/basic.c b/drivers/usbd/network_fd/basic.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/basic.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,157 @@
++/*
++ * usbd/network_fd/basic.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++#include "network.h"
++
++
++#ifdef CONFIG_USBD_NETWORK_BASIC
++/* USB BASIC Configuration ******************************************************************** */
++
++/* BASIC Communication Interface Class descriptors
++ */
++static __u8 basic_data_1[] = { 0x07, USB_DT_ENDPOINT, OUT, BULK, 0, 0x00, 0x00, };
++static __u8 basic_data_2[] = { 0x07, USB_DT_ENDPOINT, IN, BULK, 0, 0x00, 0x00, };
++static __u8 basic_comm_1[] = { 0x07, USB_DT_ENDPOINT, IN, INTERRUPT,0, 0x00, 0x0a, };
++
++static struct usb_endpoint_descriptor *basic_default[] = {
++ (struct usb_endpoint_descriptor *) &basic_data_1,
++ (struct usb_endpoint_descriptor *) &basic_data_2,
++ (struct usb_endpoint_descriptor *) &basic_comm_1, };
++u8 basic_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++/* BASIC Data Interface Alternate endpoints
++ */
++static __u8 basic_data_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (basic_default) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ LINEO_CLASS, LINEO_SUBCLASS_BASIC_NET, LINEO_BASIC_NET_CRC, 0x00,
++};
++
++static struct usb_alternate_description basic_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_BASIC_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&basic_data_alternate_descriptor,
++ endpoints:sizeof (basic_default) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: basic_default,
++ endpoint_indexes: basic_indexes,
++ },
++};
++
++
++/* BASIC Data Interface Alternate descriptions and descriptors
++ */
++
++/* BASIC Interface descriptions and descriptors
++ */
++struct usb_interface_description basic_interfaces[] = {
++ { alternates:sizeof (basic_data_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:basic_data_alternate_descriptions,},
++};
++
++/* BASIC Configuration descriptions and descriptors
++ */
++__u8 basic_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, // wLength
++ sizeof (basic_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ BMATTRIBUTE, BMAXPOWER,
++};
++
++struct usb_configuration_description basic_description[] = {
++ { iConfiguration: CONFIG_USBD_NETWORK_BASIC_DESC,
++ configuration_descriptor: (struct usb_configuration_descriptor *)basic_configuration_descriptor,
++ bNumInterfaces:sizeof (basic_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:basic_interfaces,},
++
++};
++
++/* BASIC Device Description
++ */
++static struct usb_device_descriptor basic_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++
++static struct usb_endpoint_request basic_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT, 16, 64, },
++ { 0, },
++};
++
++struct usb_device_description basic_device_description = {
++ device_descriptor: &basic_device_descriptor,
++ iManufacturer: CONFIG_USBD_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_USBD_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: basic_endpoint_requests,
++};
++
++
++void basic_init (struct usb_function_instance *function)
++{
++ basic_data_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 3 : 2;
++}
++
++struct usb_function_driver basic_function_driver = {
++ name: "network-BASIC",
++ fops: &network_fd_function_ops,
++ device_description: &basic_device_description,
++ bNumConfigurations: sizeof (basic_description) / sizeof (struct usb_configuration_description),
++ configuration_description: basic_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++#endif /* CONFIG_USBD_NETWORK_BASIC */
++
+diff -Nru a/drivers/usbd/network_fd/basic2.c b/drivers/usbd/network_fd/basic2.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/basic2.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,198 @@
++/*
++ * usbd/network_fd/basic22.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++#include "network.h"
++
++
++#ifdef CONFIG_USBD_NETWORK_BASIC2
++/* USB BASIC Configuration ******************************************************************** */
++
++/*
++ * This provides a slight amplification of the basic configuration, it moves the
++ * interrupt endpoint (if available) to a separate interface, so that it is similiar
++ * to the cdc configuration
++ */
++
++/* BASIC Communication Interface Class descriptors
++ */
++static __u8 basic2_data_1[] = { 0x07, USB_DT_ENDPOINT, OUT, BULK, 0, 0x00, 0x00, };
++static __u8 basic2_data_2[] = { 0x07, USB_DT_ENDPOINT, IN, BULK, 0, 0x00, 0x00, };
++static __u8 basic2_comm_1[] = { 0x07, USB_DT_ENDPOINT, IN, INTERRUPT,0, 0x00, 0x0a, };
++
++static __u8 *basic2_comm_endpoints[] = {
++ (struct usb_endpoint_descriptor *) &basic2_comm_1, };
++
++static __u8 *basic2_data_endpoints[] = {
++ (struct usb_endpoint_descriptor *) &basic2_data_1,
++ (struct usb_endpoint_descriptor *) &basic2_data_2, };
++
++u8 basic2_comm_indexes[] = { INT_IN, };
++u8 basic2_data_indexes[] = { BULK_OUT, BULK_IN, };
++
++
++/* BASIC2 Data Interface Alternate endpoints
++ */
++
++static __u8 basic2_comm_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (basic2_comm_endpoints) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_NETWORK_SUBCLASS, VENDOR, 0x00,
++};
++static __u8 basic2_data_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x01, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (basic2_data_endpoints) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00,
++};
++
++static struct usb_alternate_description basic2_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_BASIC2_COMM_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&basic2_comm_alternate_descriptor,
++ endpoints:sizeof (basic2_comm_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list:basic2_comm_endpoints,
++ endpoint_indexes:basic2_comm_indexes,
++ },
++};
++
++
++static struct usb_alternate_description basic2_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_BASIC2_DATA_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&basic2_data_alternate_descriptor,
++ endpoints:sizeof (basic2_data_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: basic2_data_endpoints,
++ endpoint_indexes: basic2_data_indexes,
++ },
++};
++
++
++/* BASIC Data Interface Alternate descriptions and descriptors
++ */
++
++/* BASIC Interface descriptions and descriptors
++ */
++static struct usb_interface_description basic2_interfaces[] = {
++ { alternates:sizeof (basic2_comm_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:basic2_comm_alternate_descriptions,},
++
++ { alternates:sizeof (basic2_data_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:basic2_data_alternate_descriptions,},
++};
++
++
++/* BASIC Configuration descriptions and descriptors
++ */
++__u8 basic2_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, // wLength
++ sizeof (basic2_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ BMATTRIBUTE, BMAXPOWER,
++};
++
++struct usb_configuration_description basic2_description[] = {
++ { iConfiguration: CONFIG_USBD_NETWORK_BASIC2_DESC,
++ configuration_descriptor: (struct usb_configuration_descriptor *)basic2_configuration_descriptor,
++ bNumInterfaces:sizeof (basic2_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:basic2_interfaces,},
++
++};
++
++/* BASIC Device Description
++ */
++static struct usb_device_descriptor basic2_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_BASIC2_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_BASIC2_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_BASIC2_BCDDEVICE),
++};
++
++static struct usb_endpoint_request basic2_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT, 16, 64, },
++ { 0, },
++};
++
++struct usb_device_description basic2_device_description = {
++ device_descriptor: &basic2_device_descriptor,
++ iManufacturer: CONFIG_USBD_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_USBD_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: basic2_endpoint_requests,
++};
++
++
++void basic2_init (struct usb_function_instance *function)
++{
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ basic2_comm_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 1 : 0;
++
++ printk(KERN_INFO"%s: alternate: %p endpoints: %d\n", __FUNCTION__,
++ basic2_data_alternate_descriptions,
++ basic2_data_alternate_descriptions->endpoints
++ );
++
++ printk(KERN_INFO"%s: finis\n", __FUNCTION__);
++}
++
++
++struct usb_function_driver basic2_function_driver = {
++ name: "network-BASIC2",
++ fops: &network_fd_function_ops,
++ device_description: &basic2_device_description,
++ bNumConfigurations: sizeof (basic2_description) / sizeof (struct usb_configuration_description),
++ configuration_description: basic2_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_BASIC2_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_BASIC2_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_BASIC2_BCDDEVICE),
++};
++#endif /* CONFIG_USBD_NETWORK_BASIC2 */
++
+diff -Nru a/drivers/usbd/network_fd/blan.c b/drivers/usbd/network_fd/blan.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/blan.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,251 @@
++/*
++ * usbd/network_fd/blan.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++#include "network.h"
++
++
++#ifdef CONFIG_USBD_NETWORK_BLAN
++/* USB BLAN Configuration ******************************************************************** */
++
++/*
++ * BLAN Ethernet Configuration
++ */
++
++/* Communication Interface Class descriptors
++ */
++
++static __u8 blan_data_1[] = { 0x07, USB_DT_ENDPOINT, OUT, BULK, 0, 0x00, 0x00, };
++static __u8 blan_data_2[] = { 0x07, USB_DT_ENDPOINT, IN, BULK, 0, 0x00, 0x00, };
++static __u8 blan_comm_1[] = { 0x07, USB_DT_ENDPOINT, IN, INTERRUPT,0, 0x00, 0x0a, };
++
++static __u8 blan_class_1[] = { 0x05, CS_INTERFACE, USB_ST_HEADER, 0x10, 0x01, /* CLASS_BDC_VERSION, CLASS_BDC_VERSION */ };
++static __u8 blan_class_2[] = { 0x15, CS_INTERFACE, USB_ST_MDLM, 0x00, 0x01, /* bcdVersion, bcdVersion */
++ 0x74, 0xf0, 0x3d, 0xbd, 0x1e, 0xc1, 0x44, 0x70, /* bGUID */
++ 0xa3, 0x67, 0x71, 0x34, 0xc9, 0xf5, 0x54, 0x37, /* bGUID */ };
++
++
++static __u8 blan_class_3[] = { 0x07, CS_INTERFACE, USB_ST_MDLMD, 0x01, 0x00, 0x00, 0x00, };
++
++static __u8 blan_class_4[] = { 0x0d, CS_INTERFACE, USB_ST_ENF,
++ 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x05, /* 1514 maximum frame size */
++ 0x00, 0x00, 0x00 , };
++
++static __u8 blan_class_5[] = { 0x07, CS_INTERFACE, USB_ST_NCT, 0x00, 0x00, 0x00, 0x00, };
++
++
++static struct usb_endpoint_descriptor *blan_alt_endpoints[] = {
++ (struct usb_endpoint_descriptor *) blan_data_1,
++ (struct usb_endpoint_descriptor *) blan_data_2,
++ (struct usb_endpoint_descriptor *) blan_comm_1, };
++
++u8 blan_alt_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++static struct usb_generic_class_descriptor *blan_comm_class_descriptors[] = {
++ (struct usb_generic_class_descriptor *) blan_class_1,
++ (struct usb_generic_class_descriptor *) blan_class_2,
++ (struct usb_generic_class_descriptor *) blan_class_3,
++ (struct usb_generic_class_descriptor *) blan_class_4,
++ (struct usb_generic_class_descriptor *) blan_class_5, };
++
++
++/* Data Interface Alternate descriptions and descriptors
++ */
++static __u8 blan_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (blan_alt_endpoints) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_MDLM_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00,
++};
++
++static struct usb_alternate_description blan_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_BLAN_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&blan_alternate_descriptor,
++ classes:sizeof (blan_comm_class_descriptors) / sizeof (struct usb_generic_class_descriptor *),
++ class_list: blan_comm_class_descriptors,
++ endpoints:sizeof (blan_alt_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: blan_alt_endpoints,
++ endpoint_indexes: blan_alt_indexes,
++ },
++};
++/* Interface descriptions and descriptors
++ */
++static struct usb_interface_description blan_interfaces[] = {
++ {
++ alternates: sizeof (blan_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list: blan_alternate_descriptions,
++ },
++};
++
++
++/* Configuration descriptions and descriptors
++ */
++
++static __u8 blan_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, // wLength
++ sizeof (blan_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ BMATTRIBUTE, BMAXPOWER,
++};
++
++struct usb_configuration_description blan_description[] = {
++ { iConfiguration: CONFIG_USBD_NETWORK_BLAN_DESC,
++ configuration_descriptor: (struct usb_configuration_descriptor *)blan_configuration_descriptor,
++ bNumInterfaces:sizeof (blan_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:blan_interfaces, },
++};
++
++/* Device Description
++ */
++
++static struct usb_device_descriptor blan_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++
++static struct usb_endpoint_request blan_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT, 16, 64, },
++ { 0, },
++};
++
++struct usb_device_description blan_device_description = {
++ device_descriptor: &blan_device_descriptor,
++ iManufacturer: CONFIG_USBD_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_USBD_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: blan_endpoint_requests,
++};
++
++
++void blan_init (struct usb_function_instance *function)
++{
++ struct usb_class_ethernet_networking_descriptor *ethernet;
++ struct usb_class_network_channel_descriptor *channel;
++
++ int len = 0;
++ char buf[255];
++
++ buf[0] = 0;
++
++ blan_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 3 : 2;
++
++ // Update the iMACAddress field in the ethernet descriptor
++ {
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++ char address_str[14];
++ snprintf(address_str, 13, "%02x%02x%02x%02x%02x%02x",
++ local_dev_addr[0], local_dev_addr[1], local_dev_addr[2],
++ local_dev_addr[3], local_dev_addr[4], local_dev_addr[5]);
++#else
++ char address_str[20];
++ sprintf(address_str, "%02x%02x%02x%02x%02x%02x",
++ local_dev_addr[0], local_dev_addr[1], local_dev_addr[2],
++ local_dev_addr[3], local_dev_addr[4], local_dev_addr[5]);
++#endif
++ //printk(KERN_INFO"%s: alloc mac string\n", __FUNCTION__);
++ if ((ethernet = (struct usb_class_ethernet_networking_descriptor *)blan_class_4))
++ ethernet->iMACAddress = usbd_alloc_string(address_str);
++ //printk(KERN_INFO"%s: alloc mac string finis\n", __FUNCTION__);
++ }
++ //printk(KERN_INFO"%s: alloc channel string\n", __FUNCTION__);
++ if ((channel = (struct usb_class_network_channel_descriptor *)blan_class_5))
++ channel->iName = usbd_alloc_string(system_utsname.nodename);
++ //printk(KERN_INFO"%s: alloc channel string finis\n", __FUNCTION__);
++
++#ifdef CONFIG_USBD_NETWORK_BLAN_PADBYTES
++ blan_class_3[6] = CONFIG_USBD_NETWORK_BLAN_PADBYTES;
++ len += sprintf(buf + len, "PADBYTES: %02x ", blan_class_3[6]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_PADBEFORE
++ blan_class_3[5] |= BMDATA_PADBEFORE;
++ len += sprintf(buf + len, "PADBEFORE: %02x ", blan_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_PADAFTER
++ blan_class_3[5] |= BMDATA_PADAFTER;
++ len += sprintf(buf + len, "PADAFTER: %02x ", blan_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_CRC
++ blan_class_3[5] |= BMDATA_CRC;
++ len += sprintf(buf + len, "CRC: %02x ", blan_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_FERMAT
++ blan_class_3[5] |= BMDATA_FERMAT;
++ len += sprintf(buf + len, "FERMAT: %02x ",blan_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_HOSTNAME
++ blan_class_3[5] |= BMDATA_HOSTNAME;
++ len += sprintf(buf + len, "HOSTNAME: %02x ",blan_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_NOBRIDGE
++ blan_class_3[4] |= BMNETWORK_NOBRIDGE;
++ len += sprintf(buf + len, "NOBRIDGE: %02x ",blan_class_3[4]);
++#endif
++ if (strlen(buf))
++ printk(KERN_INFO"%s: %s\n", __FUNCTION__, buf);
++}
++
++struct usb_function_driver blan_function_driver = {
++ name: "network-BLAN",
++ fops: &network_fd_function_ops,
++ device_description: &blan_device_description,
++ bNumConfigurations: sizeof (blan_description) / sizeof (struct usb_configuration_description),
++ configuration_description: blan_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++#endif /* CONFIG_USBD_NETWORK_BLAN */
++
+diff -Nru a/drivers/usbd/network_fd/cdc.c b/drivers/usbd/network_fd/cdc.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/cdc.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,222 @@
++/*
++ * usbd/network_fd/cdc.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++#include "network.h"
++
++
++
++#ifdef CONFIG_USBD_NETWORK_CDC
++/* USB CDC Configuration ********************************************************************* */
++
++/* CDC Communication Interface Class descriptors
++ */
++static __u8 cdc_data_1[] = { 0x07, USB_DT_ENDPOINT, 0 | OUT, BULK, 0, 0x00, 0x00, };
++static __u8 cdc_data_2[] = { 0x07, USB_DT_ENDPOINT, 0 | IN, BULK, 0, 0x00, 0x00, };
++
++static __u8 cdc_comm_1[] = { 0x07, USB_DT_ENDPOINT, 0 | IN, INTERRUPT,0, 0x00, 0x0a, };
++
++static __u8 cdc_class_1[] = { 0x05, CS_INTERFACE, USB_ST_HEADER, 0x10, 0x01, /* CLASS_BDC_VERSION, CLASS_BDC_VERSION */ };
++static __u8 cdc_class_2[] = {
++ 0x0d, CS_INTERFACE, USB_ST_ENF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x05, /* 1514 maximum frame size */
++ 0x00, 0x00, 0x00 , };
++static __u8 cdc_class_3[] = { 0x05, CS_INTERFACE, USB_ST_UF, 0x00, 0x01, /* bMasterInterface, bSlaveInterface */};
++
++
++static __u8 *cdc_comm_class_descriptors[] = {
++ (struct usb_generic_class_descriptor *) &cdc_class_1,
++ (struct usb_generic_class_descriptor *) &cdc_class_2,
++ (struct usb_generic_class_descriptor *) &cdc_class_3, };
++
++static __u8 *cdc_data_endpoints[] = {
++ (struct usb_endpoint_descriptor *) &cdc_data_1,
++ (struct usb_endpoint_descriptor *) &cdc_data_2, };
++static __u8 *cdc_comm_endpoints[] = {
++ (struct usb_endpoint_descriptor *) &cdc_comm_1, };
++
++u8 cdc_comm_indexes[] = { INT_IN, };
++u8 cdc_data_indexes[] = { BULK_OUT, BULK_IN, };
++
++
++/* Data Interface Alternate descriptions and descriptors
++ */
++static __u8 cdc_comm_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (cdc_comm_endpoints) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_ENCM_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00,
++};
++static __u8 cdc_nodata_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x01, 0x00, // bInterfaceNumber, bAlternateSetting
++ 0x00, // bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00,
++};
++static __u8 cdc_data_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x01, 0x01, // bInterfaceNumber, bAlternateSetting
++ sizeof (cdc_data_endpoints) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00,
++};
++
++static struct usb_alternate_description cdc_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_CDC_COMM_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usb_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++ endpoints:sizeof (cdc_comm_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: cdc_comm_endpoints,
++ endpoint_indexes: cdc_comm_indexes,
++ },
++};
++
++
++static struct usb_alternate_description cdc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_CDC_NODATA_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&cdc_nodata_alternate_descriptor, },
++ { iInterface: CONFIG_USBD_NETWORK_CDC_DATA_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&cdc_data_alternate_descriptor,
++ endpoints:sizeof (cdc_data_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: cdc_data_endpoints,
++ endpoint_indexes: cdc_data_indexes,
++ },
++};
++
++/* Interface descriptions and descriptors
++ */
++struct usb_interface_description cdc_interfaces[] = {
++ { alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,},
++
++ { alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,},
++};
++
++/* Configuration descriptions and descriptors
++ */
++
++__u8 cdc_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, // wLength
++ sizeof (cdc_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ BMATTRIBUTE, BMAXPOWER,
++};
++
++struct usb_configuration_description cdc_description[] = {
++ { iConfiguration: CONFIG_USBD_NETWORK_CDC_DESC,
++ configuration_descriptor: (struct usb_configuration_descriptor *)cdc_configuration_descriptor,
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:cdc_interfaces,},
++};
++
++
++
++/* Device Description
++ */
++
++static struct usb_device_descriptor cdc_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++
++static struct usb_endpoint_request cdc_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 1, 1, USB_DIR_OUT | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 1, 1, USB_DIR_IN | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT, 16, 64, },
++ { 0, },
++};
++
++struct usb_device_description cdc_device_description = {
++ device_descriptor: &cdc_device_descriptor,
++ iManufacturer: CONFIG_USBD_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_USBD_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: cdc_endpoint_requests,
++};
++
++
++
++void cdc_init (struct usb_function_instance *function)
++{
++ struct usb_class_ethernet_networking_descriptor *ethernet;
++
++ cdc_comm_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 1 : 0;
++
++ // Update the iMACAddress field in the ethernet descriptor
++ {
++ char address_str[14];
++ snprintf(address_str, 13, "%02x%02x%02x%02x%02x%02x",
++ remote_dev_addr[0], remote_dev_addr[1], remote_dev_addr[2],
++ remote_dev_addr[3], remote_dev_addr[4], remote_dev_addr[5]);
++
++ if ((ethernet = (struct usb_class_ethernet_networking_descriptor *)cdc_class_2)) {
++ if (ethernet->iMACAddress) {
++ usbd_dealloc_string(ethernet->iMACAddress);
++ }
++ ethernet->iMACAddress = usbd_alloc_string(address_str);
++ }
++ }
++}
++
++
++struct usb_function_driver cdc_function_driver = {
++ name: "network-CDC",
++ fops: &network_fd_function_ops,
++ device_description: &cdc_device_description,
++ bNumConfigurations: sizeof (cdc_description) / sizeof (struct usb_configuration_description),
++ configuration_description: cdc_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++#endif /* CONFIG_USBD_NETWORK_CDC */
++
+diff -Nru a/drivers/usbd/network_fd/fermat.c b/drivers/usbd/network_fd/fermat.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/fermat.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,132 @@
++/*
++ * usbd/network_fd/fermat.c - Network Function Driver
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#ifdef CONFIG_USBD_NETWORK_BLAN_FERMAT
++
++#include "fermat.h"
++
++#ifndef FERMAT_DEFINED
++typedef unsigned char BYTE;
++typedef struct fermat {
++ int length;
++ BYTE power[256];
++} FERMAT;
++#endif
++
++
++static int fermat_setup(FERMAT *p, int seed){
++ int i = 0;
++ unsigned long x,y;
++ y = 1;
++ do{
++ x = y;
++ p->power[i] = ( x == 256 ? 0 : x);
++ y = ( seed * x ) % 257;
++ i += 1;
++ }while( y != 1);
++ p->length = i;
++ return i;
++}
++
++static void fermat_xform(FERMAT *p, BYTE *data, int length){
++ BYTE *pw = p->power;
++ int i, j;
++ BYTE * q ;
++ for(i = 0, j=0, q = data; i < length; i++, j++, q++){
++ if(j>=p->length){
++ j = 0;
++ }
++ *q ^= pw[j];
++ }
++}
++
++static FERMAT default_fermat;
++static const int primitive_root = 5;
++void fermat_init(){
++ (void) fermat_setup(&default_fermat, primitive_root);
++}
++
++// Here are the public official versions.
++// Change the primitive_root above to another primitive root
++// if you need better scatter. Possible values are 3 and 7
++
++
++void fermat_encode(BYTE *data, int length){
++ fermat_xform(&default_fermat, data, length);
++}
++
++void fermat_decode(BYTE *data, int length){
++ fermat_xform(&default_fermat, data, length);
++}
++
++
++// Note: the seed must be a "primitive root" of 257. This means that
++// the return value of the setup routine must be 256 (otherwise the
++// seed is not a primitive root. The routine will still work fine
++// but will be less pseudo-random.
++
++#undef TEST
++#if TEST
++#include <stdio.h>
++#include <memory.h>
++
++// Use FERMAT in two ways: to encode, and to generate test data.
++
++main(){
++ //Note 3, 5, and 7 are primitive roots of 257
++ // 11 is not a primitive root
++ FERMAT three, five, seven;
++
++ FERMAT three2;
++ printf("Cycle lengths: 3,5,7 %d %d %d \n",
++ fermat_setup(&three, 3),
++ fermat_setup(&five, 5),
++ fermat_setup(&seven, 7));
++ three2=three; // Copy data from three
++ fermat_xform(&three,three2.power,three2.length);
++ fermat_xform(&five,three2.power,three2.length);
++ fermat_xform(&seven,three2.power,three2.length);
++ fermat_xform(&seven,three2.power,three2.length);
++ fermat_xform(&five,three2.power,three2.length);
++ fermat_xform(&three,three2.power,three2.length);
++
++ //At this stage, three2 and three should be identical
++ if(memcpy(&three,&three2,sizeof(FERMAT))){
++ printf("Decoded intact\n");
++ }
++
++ fermat_init();
++ fermat_encode(three2.power,256);
++
++}
++#endif
++
++#endif /* CONFIG_USBD_NETWORK_BLAN_FERMAT */
++
+diff -Nru a/drivers/usbd/network_fd/fermat.h b/drivers/usbd/network_fd/fermat.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/fermat.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,39 @@
++/*
++ * usbd/network_fd/fermat.h - Network Function Driver
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ */
++
++#ifndef FERMAT_DEFINED
++#define FERMAT_DEFINED 1
++typedef unsigned char BYTE;
++typedef struct fermat {
++ int length;
++ BYTE power[256];
++} FERMAT;
++
++void fermat_init(void);
++void fermat_encode(BYTE *data, int length);
++void fermat_decode(BYTE *data, int length);
++#endif
++
++
+diff -Nru a/drivers/usbd/network_fd/network.c b/drivers/usbd/network_fd/network.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/network.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,2112 @@
++/*
++ * usbd/network_fd/network.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ * This network function driver intended to interoperate with
++ * Belcarra's USBLAN Class drivers.
++ *
++ * These are available for Windows, Linux and Mac OSX. For more
++ * information and to download a copy for testing:
++ *
++ * http://www.belcarra.com/usblan/
++ *
++ *
++ * Notes
++ *
++ * 1. If compiled into the kernel this driver can be used with NFSROOT to
++ * provide the ROOT filesystem. Please note that the kernel NFSROOT support
++ * (circa 2.4.20) can have problems if there are multiple interfaces. So
++ * it is best to ensure that there are no other network interfaces compiled
++ * in.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++MODULE_AUTHOR ("sl@belcarra.com, balden@belcarra.com");
++
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("GPL");
++#endif
++
++MODULE_DESCRIPTION ("USB Network Function");
++
++
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/netdevice.h>
++#include <linux/skbuff.h>
++#include <linux/etherdevice.h>
++#include <net/arp.h>
++#include <linux/rtnetlink.h>
++#include <linux/smp_lock.h>
++#include <linux/ctype.h>
++#include <linux/time.h>
++#include <linux/timer.h>
++#include <linux/string.h>
++#include <linux/atmdev.h>
++#include <linux/pkt_sched.h>
++#include <linux/random.h>
++#include <linux/utsname.h>
++
++#include <linux/ip.h>
++#include <linux/if_ether.h>
++#include <linux/in.h>
++#include <linux/inetdevice.h>
++
++#include <linux/kmod.h>
++
++#include <asm/uaccess.h>
++#include <asm/system.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++USBD_MODULE_INFO ("network_fd 2.0-beta");
++
++#include "network.h"
++#ifdef CONFIG_USBD_NETWORK_BLAN_FERMAT
++#include "fermat.h"
++#endif
++
++
++#if defined(CONFIG_USBD_NETWORK_CDC)
++
++static u32 cdc = 0;
++MODULE_PARM (cdc, "i");
++MODULE_PARM_DESC (cdc, "Enable CDC mode");
++void cdc_init(struct usb_function_instance *);
++
++extern struct usb_function_driver cdc_function_driver;
++
++#if defined(CONFIG_USBD_NETWORK_NETWORK_CDC_MYDHCPD)
++extern u_int8_t * checkfordhcp(struct net_device *net_device, u_int8_t *, int, int* );
++#endif
++
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BASIC
++static u32 basic = 0;
++MODULE_PARM (basic, "i");
++MODULE_PARM_DESC (basic, "Enable BASIC mode");
++void basic_init(struct usb_function_instance *);
++extern struct usb_function_driver basic_function_driver;
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BASIC2
++static u32 basic2 = 0;
++MODULE_PARM (basic, "i");
++MODULE_PARM_DESC (basic2, "Enable BASIC2 mode");
++void basic2_init(struct usb_function_instance *);
++extern struct usb_function_driver basic2_function_driver;
++#endif
++
++
++#ifdef CONFIG_USBD_NETWORK_SAFE
++static u32 safe = 0;
++MODULE_PARM (safe, "i");
++MODULE_PARM_DESC (safe, "Enable SAFE mode");
++void safe_init(struct usb_function_instance *);
++extern struct usb_function_driver safe_function_driver;
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BLAN
++static u32 blan = 0;
++MODULE_PARM (blan, "i");
++MODULE_PARM_DESC (blan, "Enable BLAN mode");
++void blan_init(struct usb_function_instance *);
++extern struct usb_function_driver blan_function_driver;
++#endif
++
++static struct usb_function_driver *function_driver = NULL;
++
++
++/* Module Parameters ************************************************************************* */
++
++wait_queue_head_t usb_netif_wq;
++#ifdef CONFIG_USBD_NET_NFS_SUPPORT
++int usb_is_configured;
++#endif
++
++#define CONFIG_USBD_NETWORK_ALLOW_SETID 1
++
++
++
++#ifdef CONFIG_USBD_NETWORK_ALLOW_SETID
++// override vendor ID
++static u32 vendor_id;
++MODULE_PARM (vendor_id, "i");
++MODULE_PARM_DESC (vendor_id, "vendor id");
++
++// override product ID
++static u32 product_id;
++MODULE_PARM (product_id, "i");
++MODULE_PARM_DESC (product_id, "product id");
++#endif
++
++// override local mac address
++#ifdef CONFIG_USBD_NETWORK_LOCAL_MACADDR
++static char *local_mac_address_str = CONFIG_USBD_NETWORK_LOCAL_MACADDR;
++#else
++static char *local_mac_address_str;
++#endif
++MODULE_PARM (local_mac_address_str, "s");
++MODULE_PARM_DESC (local_mac_address_str, "Local MAC");
++
++// override remote mac address
++#ifdef CONFIG_USBD_NETWORK_REMOTE_MACADDR
++static char *remote_mac_address_str = CONFIG_USBD_NETWORK_REMOTE_MACADDR;
++#else
++static char *remote_mac_address_str;
++#endif
++MODULE_PARM (remote_mac_address_str, "s");
++MODULE_PARM_DESC (remote_mac_address_str, "Remote MAC");
++
++
++#ifdef CONFIG_USBD_NETWORK_EP0TEST
++static u32 ep0test;
++MODULE_PARM (ep0test, "i");
++MODULE_PARM_DESC (ep0test, "Test EP0 String Handling - set to ep0 packetsize [8,16,32,64]");
++#endif
++
++
++static u32 zeroconf = 0;
++MODULE_PARM (zeroconf, "i");
++MODULE_PARM_DESC (zeroconf, "Use usbz%d for network name");
++
++#define NETWORK_CREATED 0x01
++#define NETWORK_REGISTERED 0x02
++#define NETWORK_DESTROYING 0x04
++#define NETWORK_ENABLED 0x08
++#define NETWORK_ATTACHED 0x10
++#define NETWORK_OPEN 0x20
++
++
++#define MCCI_ENABLE_CRC 0x03
++#define BELCARRA_GETMAC 0x04
++
++#define BELCARRA_SETTIME 0x04
++#define BELCARRA_SETIP 0x05
++#define BELCARRA_SETMSK 0x06
++#define BELCARRA_SETROUTER 0x07
++#define BELCARRA_SETDNS 0x08
++#define BELCARRA_PING 0x09
++#define BELCARRA_SETFERMAT 0x0a
++#define BELCARRA_HOSTNAME 0x0b
++
++
++#define RFC868_OFFSET_TO_EPOCH 0x83AA7E80 // RFC868 - seconds from midnight on 1 Jan 1900 GMT to Midnight 1 Jan 1970 GMT
++
++
++__u8 local_dev_addr[ETH_ALEN];
++
++__u8 remote_dev_addr[ETH_ALEN];
++static __u8 zeros[ETH_ALEN];
++
++static __u32 ip_addr;
++static __u32 router_ip;
++static __u32 network_mask;
++static __u32 dns_server_ip;
++
++/* Prevent overlapping of bus administrative functions:
++ *
++ * network_function_enable
++ * network_function_disable
++ * network_hard_start_xmit
++ */
++DECLARE_MUTEX(usbd_network_sem);
++
++
++struct net_device Network_net_device;
++struct usb_network_private Usb_network_private;
++
++static void network_send_int_blan(struct usb_function_instance *function, int connected );
++static void notification_schedule_bh (void);
++static int network_urb_sent_bulk (struct urb *urb, int urb_rc);
++static int network_urb_sent_int (struct urb *urb, int urb_rc);
++
++
++//_________________________________________________________________________________________________
++
++/*
++ * Synchronization
++ *
++ *
++ * Notification bottom half
++ *
++ * This is a scheduled task that will send an interrupt notification. Because it
++ * is called from the task scheduler context it needs to verify that the device is
++ * still usable.
++ *
++ * static int network_send_int_blan(struct usb_device_instance *, int )
++ * static void notification_bh (void *)
++ * void notification_schedule_bh (void)
++ *
++ *
++ * Netdevice functions
++ *
++ * These are called by the Linux network layer. They must be protected by irq locks
++ * if necessary to prevent interruption by IRQ level events.
++ *
++ * int network_init (struct net_device *net_device)
++ * void network_uninit (struct net_device *net_device)
++ * int network_open (struct net_device *net_device)
++ * int network_stop (struct net_device *net_device)
++ * struct net_device_stats *network_get_stats (struct net_device *net_device)
++ * int network_set_mac_addr (struct net_device *net_device, void *p)
++ * void network_tx_timeout (struct net_device *net_device)
++ * int network_set_config (struct net_device *net_device, struct ifmap *map)
++ * int network_stop (struct net_device *net_device)
++ * int network_hard_start_xmit (struct sk_buff *skb, struct net_device *net_device)
++ * int network_do_ioctl (struct net_device *net_device, struct ifreq *rp, int cmd)
++ *
++ *
++ * Data bottom half functions
++ *
++ * These are called from the bus bottom half handler.
++ *
++ * static int network_recv (struct usb_network_private *, struct net_device *, struct sk_buff *)
++ * int network_recv_urb (struct urb *)
++ * int network_urb_sent (struct urb *, int )
++ *
++ *
++ * Hotplug bottom half:
++ *
++ * This is a scheduled task that will send do a hotplug call. Because it is
++ * called from the task scheduler context it needs to verify that the
++ * device is still usable.
++ *
++ * static int hotplug_attach (__u32 ip, __u32 mask, __u32 router, int attach)
++ * static void hotplug_bh (void *data)
++ * void hotplug_schedule_bh (void)
++ *
++ *
++ * Irq level functions:
++ *
++ * These are called at interrupt time do process or respond to USB setup
++ * commands.
++ *
++ * int network_recv_setup_irq (struct usb_device_request *)
++ * void network_event_irq (struct usb_function_instance *function, usb_device_event_t event, int data)
++ *
++ *
++ * Enable and disable functions:
++ *
++ * void network_function_enable (struct usb_function_instance *, struct usb_function_instance *)
++ * void network_function_disable (struct usb_function_instance *function)
++ *
++ *
++ * Driver initialization and exit:
++ *
++ * static int network_create (void)
++ * static void network_destroy (void)
++ *
++ * int network_modinit (void)
++ * void network_modexit (void)
++ */
++
++//_________________________________________________________________________________________________
++
++/*
++ * If the following are defined we implement the crc32_copy routine using
++ * Duff's device. This will unroll the copy loop by either 4 or 8. Do not
++ * use these without profiling to test if it actually helps on any specific
++ * device.
++ */
++#undef CONFIG_USBD_NETWORK_CRC_DUFF4
++#undef CONFIG_USBD_NETWORK_CRC_DUFF8
++
++static __u32 *network_crc32_table;
++
++#define CRC32_INIT 0xffffffff // Initial FCS value
++#define CRC32_GOOD 0xdebb20e3 // Good final FCS value
++
++#define CRC32_POLY 0xedb88320 // Polynomial for table generation
++
++#define COMPUTE_FCS(val, c) (((val) >> 8) ^ network_crc32_table[((val) ^ (c)) & 0xff])
++
++//_________________________________________________________________________________________________
++// crc32_copy
++
++/**
++ * Generate the crc32 table
++ *
++ * return non-zero if malloc fails
++ */
++static int make_crc_table(void)
++{
++ u32 n;
++ RETURN_ZERO_IF(network_crc32_table);
++ RETURN_ENOMEM_IF(!(network_crc32_table = (u32 *)ckmalloc(256*4, GFP_KERNEL)));
++ for (n = 0; n < 256; n++) {
++ int k;
++ u32 c = n;
++ for (k = 0; k < 8; k++) {
++ c = (c & 1) ? (CRC32_POLY ^ (c >> 1)) : (c >> 1);
++ }
++ network_crc32_table[n] = c;
++ }
++ return 0;
++}
++
++#if !defined(CONFIG_USBD_NETWORK_CRC_DUFF4) && !defined(CONFIG_USBD_NETWORK_CRC_DUFF8)
++/**
++ * Copies a specified number of bytes, computing the 32-bit CRC FCS as it does so.
++ *
++ * dst Pointer to the destination memory area.
++ * src Pointer to the source memory area.
++ * len Number of bytes to copy.
++ * val Starting value for the CRC FCS.
++ *
++ * Returns Final value of the CRC FCS.
++ *
++ * @sa crc32_pad
++ */
++static __u32 __inline__ crc32_copy (__u8 *dst, __u8 *src, int len, __u32 val)
++{
++ for (; len-- > 0; val = COMPUTE_FCS (val, *dst++ = *src++));
++ return val;
++}
++
++#else /* DUFFn */
++
++/**
++ * Copies a specified number of bytes, computing the 32-bit CRC FCS as it does so.
++ *
++ * dst Pointer to the destination memory area.
++ * src Pointer to the source memory area.
++ * len Number of bytes to copy.
++ * val Starting value for the CRC FCS.
++ *
++ * Returns Final value of the CRC FCS.
++ *
++ * @sa crc32_pad
++ */
++static __u32 crc32_copy (__u8 *dst, __u8 *src, int len, __u32 val)
++{
++#if defined(CONFIG_USBD_NETWORK_CRC_DUFF8)
++ int n = (len + 7) / 8;
++ switch (len % 8)
++#elif defined(CONFIG_USBD_NETWORK_CRC_DUFF4)
++ int n = (len + 3) / 4;
++ switch (len % 4)
++#endif
++ {
++ case 0: do {
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++#if defined(CONFIG_USBD_NETWORK_CRC_DUFF8)
++ case 7:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++ case 6:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++ case 5:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++ case 4:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++#endif
++ case 3:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++ case 2:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++ case 1:
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++ } while (--n > 0);
++ }
++ return val;
++}
++#endif /* DUFFn */
++
++
++//_________________________________________________________________________________________________
++// crc32_pad
++
++/* crc32_pad - pad and calculate crc32
++ *
++ * Returns - CRC FCS
++ */
++static __u32 __inline__ crc32_pad (__u8 *dst, int len, __u32 val)
++{
++ for (; len-- > 0; val = COMPUTE_FCS (val, *dst++ = '\0'));
++ return val;
++}
++
++//_________________________________________________________________________________________________
++// network_send_int
++//
++
++/* network_send_int_blan - send an interrupt notification response
++ *
++ * Generates a response urb on the notification (INTERRUPT) endpoint.
++ * Return a non-zero result code to STALL the transaction.
++ *
++ * This is called from either a scheduled task or from the process context
++ * that calls network_open() or network_close().
++ *
++ */
++static void network_send_int_blan(struct usb_function_instance *function, int connected )
++{
++ struct urb *urb;
++ struct cdc_notification_descriptor *cdc;
++ int rc;
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ //printk(KERN_INFO"%s: device: %p\n", __FUNCTION__, device);
++
++ /*
++ * This needs to lock out interrupts as network_event_irq can
++ * change the NETWORK_ATTACHED status
++ */
++ unsigned long flags;
++ local_irq_save(flags);
++ do {
++ BREAK_IF(!function);
++
++
++ BREAK_IF(network_private->network_type != network_blan);
++ BREAK_IF(!network_private->have_interrupt);
++
++ BREAK_IF(!(network_private->flags & NETWORK_ATTACHED));
++
++ //printk(KERN_INFO"%s: connected: %d network: %d %d\n", __FUNCTION__, connected,
++ // network_private->network_type, network_blan);
++
++ BREAK_IF(usbd_bus_status(function) != USBD_OK);
++
++ if (network_private->int_urb) {
++ printk(KERN_INFO"%s: int_urb: %p\n", __FUNCTION__, network_private->int_urb);
++ usbd_cancel_urb_irq(network_private->int_urb);
++ network_private->int_urb = NULL;
++ }
++
++ BREAK_IF(!(urb = usbd_alloc_urb (function, INT_IN,
++ sizeof(struct cdc_notification_descriptor), network_urb_sent_int)));
++
++ urb->actual_length = sizeof(struct cdc_notification_descriptor);
++ memset(urb->buffer, 0, sizeof(struct cdc_notification_descriptor));
++
++ cdc = (struct cdc_notification_descriptor *)urb->buffer;
++
++ cdc->bmRequestType = 0xa1;
++ cdc->bNotification = 0x00;
++ cdc->wValue = connected ? 0x01 : 0x00;
++ cdc->wIndex = 0x01; // XXX interface - check that this is correct
++
++
++ network_private->int_urb = urb;
++ //printk(KERN_INFO"%s: int_urb: %p\n", __FUNCTION__, urb);
++ BREAK_IF (!(rc = usbd_send_urb (urb)));
++
++ printk(KERN_ERR"%s: usbd_send_urb failed err: %x\n", __FUNCTION__, rc);
++ urb->privdata = NULL;
++ network_private->int_urb = NULL;
++ usbd_dealloc_urb (urb);
++
++ } while(0);
++ local_irq_restore(flags);
++}
++
++
++/* notification_bh - Bottom half handler to send a notification status
++ *
++ * Send a notification with open/close status
++ *
++ * It should not be possible for this to be called more than once at a time
++ * as it is only called via schedule_task() which protects against a second
++ * invocation.
++ */
++static void notification_bh (void *data)
++{
++ network_send_int_blan(Usb_network_private.function, Usb_network_private.flags & NETWORK_OPEN);
++ MOD_DEC_USE_COUNT;
++}
++
++/* notification_schedule_bh - schedule a call for notification_bh
++ */
++static void notification_schedule_bh (void)
++{
++ MOD_INC_USE_COUNT;
++ if (!schedule_task (&Usb_network_private.notification_bh))
++ MOD_DEC_USE_COUNT;
++}
++
++
++//______________________________________Network Layer Functions____________________________________
++
++/*
++ * In general because the functions are called from an independant layer it is necessary
++ * to verify that the device is still ok and to lock interrupts out to prevent in-advertant
++ * closures while in progress.
++ */
++
++/* network_init -
++ *
++ * Initializes the specified network device.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_init (struct net_device *net_device)
++{
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ return 0;
++}
++
++
++/* network_uninit -
++ *
++ * Uninitializes the specified network device.
++ */
++static void network_uninit (struct net_device *net_device)
++{
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ return;
++}
++
++
++/* network_open -
++ *
++ * Opens the specified network device.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_open (struct net_device *net_device)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ // XXX should this be before or after the preceeding netif_running() test?
++ MOD_INC_USE_COUNT;
++ network_private->flags |= NETWORK_OPEN;
++ netif_wake_queue (net_device);
++ network_send_int_blan(network_private->function, 1);
++
++#ifdef CONFIG_USBD_NET_NFS_SUPPORT
++ if (!usb_is_configured) {
++ if (!in_interrupt()) {
++ printk(KERN_ERR"Please replug USB cable and then ifconfig host interface.\n");
++ interruptible_sleep_on(&usb_netif_wq);
++ }
++ else {
++ printk(KERN_ERR"Wanring! In interrupt\n");
++ }
++ }
++#endif
++ return 0;
++}
++
++
++/* network_stop -
++ *
++ * Stops the specified network device.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_stop (struct net_device *net_device)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ //netif_stop_queue (net_device);
++
++ network_private->flags &= ~NETWORK_OPEN;
++ network_send_int_blan(network_private->function, 0);
++
++ MOD_DEC_USE_COUNT;
++ return 0;
++}
++
++
++/* network_get_stats -
++ *
++ * Gets statistics from the specified network device.
++ *
++ * Returns pointer to net_device_stats structure with the required information.
++ */
++static struct net_device_stats *network_get_stats (struct net_device *net_device)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++ return &network_private->stats;
++}
++
++
++/* network_set_mac_addr
++ *
++ * Sets the MAC address of the specified network device. Fails if the device is in use.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_set_mac_addr (struct net_device *net_device, void *p)
++{
++ struct sockaddr *addr = p;
++ unsigned long flags;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ RETURN_EBUSY_IF(netif_running (net_device));
++ local_irq_save(flags);
++ memcpy (net_device->dev_addr, addr->sa_data, net_device->addr_len);
++ local_irq_restore(flags);
++ return 0;
++}
++
++
++/* network_tx_timeout -
++ *
++ * Tells the specified network device that its current transmit attempt has timed out.
++ */
++static void network_tx_timeout (struct net_device *net_device)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++#if 0
++ //printk(KERN_ERR"%s:\n", __FUNCTION__);
++ network_private->stats.tx_errors++;
++ network_private->stats.tx_dropped++;
++ usbd_cancel_urb_irq (network_private->bus, NULL);
++#endif
++#if 0
++ // XXX attempt to wakeup the host...
++ if ((network_private->network_type == network_blan) && (network_private->flags & NETWORK_OPEN)) {
++ notification_schedule_bh();
++ }
++#endif
++}
++
++
++/** network_set_config -
++ *
++ * Sets the specified network device's configuration. Fails if the device is in use.
++ *
++ * map An ifmap structure containing configuration values.
++ * Those values which are non-zero/non-null update the corresponding fields
++ * in net_device.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_set_config (struct net_device *net_device, struct ifmap *map)
++{
++ RETURN_EBUSY_IF(netif_running (net_device));
++ if (map->base_addr)
++ net_device->base_addr = map->base_addr;
++ if (map->mem_start)
++ net_device->mem_start = map->mem_start;
++ if (map->irq)
++ net_device->irq = map->irq;
++ return 0;
++}
++
++
++/* network_change_mtu -
++ *
++ * Sets the specified network device's MTU. Fails if the new value is larger and
++ * the device is in use.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_change_mtu (struct net_device *net_device, int mtu)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ RETURN_EBUSY_IF(netif_running (net_device));
++ RETURN_EBUSY_IF(mtu > network_private->mtu);
++
++ net_device->mtu = mtu;
++ return 0;
++}
++
++//_________________________________________________________________________________________________
++// network_hard_start_xmit
++
++/* network_hard_start_xmit - start sending an skb
++ *
++ * Starts a network device's transmit function.
++ * Called by kernel network layer to transmit a frame on this device.
++ * Grab locks and pass to @c netproto_do_xmit().
++ * The network layer flow control is managed to prevent more than
++ * @c device->max_queue_entries from being outstanding.
++ *
++ * skb Pointer to the sk_buff structure to be sent.
++ * net_device Specifies the device by pointing to its net_device struct.
++ *
++ * Return non-zero (1) if busy.
++ */
++static int network_hard_start_xmit (struct sk_buff *skb, struct net_device *net_device)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++ struct usb_function_instance *function = network_private->function;
++ struct urb *urb = NULL;
++ int len = skb->len;
++ int rc = 1;
++ int in_pkt_sz;
++
++ down(&usbd_network_sem);
++ do {
++
++
++#if 0
++ printk(KERN_INFO"%s: %s len: %d encap: %d\n", __FUNCTION__, net_device->name, skb->len, network_private->encapsulation);
++ printk(KERN_INFO"start_xmit: len: %x head: %p data: %p tail: %p\n",
++ skb->len, skb->head, skb->data, skb->tail);
++ {
++ __u8 *cp = skb->data;
++ int i;
++ for (i = 0; i < skb->len; i++) {
++ if ((i%32) == 0) {
++ printk("\ntx[%2x] ", i);
++ }
++ printk("%02x ", *cp++);
++ }
++ printk("\n");
++ }
++#endif
++
++ THROW_IF(!(network_private->flags & NETWORK_ATTACHED), not_ok);
++ THROW_IF(!netif_carrier_ok (net_device), not_ok);
++ THROW_IF(usbd_bus_status(function) != USBD_OK, not_ok);
++
++#if defined(CONFIG_USBD_NETWORK_CDC)
++ // verify interface is enabled - non-zero altsetting means data is enabled
++ THROW_IF(!usbd_interface_AltSetting(function, DATA_INTF), not_ok);
++#endif
++ in_pkt_sz = usbd_endpoint_wMaxPacketSize(function, BULK_IN, usbd_high_speed(function));
++
++ // stop queue, it will be restart only when we are ready for another skb
++ netif_stop_queue (net_device);
++
++ // lock and update some stats
++ network_private->stopped++;
++ network_private->queued_entries++;
++ network_private->queued_bytes += skb->len;
++
++
++ // Set the timestamp for tx timeout
++ net_device->trans_start = jiffies;
++
++ switch (network_private->encapsulation) {
++ case simple_crc:
++ //printk(KERN_INFO"%s: BASIC_CRC\n", __FUNCTION__);
++ {
++ u32 crc;
++
++ // allocate urb 5 bytes larger than required
++ if (!(urb = usbd_alloc_urb (function, BULK_IN,
++ skb->len + 5 + in_pkt_sz, network_urb_sent_bulk )))
++ {
++ printk(KERN_ERR"%s: urb alloc failed len: %d endpoint: %02x\n",
++ __FUNCTION__, skb->len,
++ usbd_endpoint_bEndpointAddress(function, BULK_IN,
++ usbd_high_speed(function)));
++ return -ENOMEM;
++ }
++
++ // copy and crc skb->len bytes
++ crc = crc32_copy(urb->buffer, skb->data, skb->len, CRC32_INIT);
++ urb->actual_length = skb->len;
++
++ // add a pad byte if required to ensure a short packet, usbdnet driver
++ // will correctly handle pad byte before or after CRC, but the MCCI driver
++ // wants it before the CRC.
++ if ((urb->actual_length % in_pkt_sz) == (in_pkt_sz - 4)) {
++ crc = crc32_pad(urb->buffer + urb->actual_length, 1, crc);
++ urb->actual_length++;
++ }
++
++ // munge and append crc
++ crc = ~crc;
++ urb->buffer[urb->actual_length++] = crc & 0xff;
++ urb->buffer[urb->actual_length++] = (crc >> 8) & 0xff;
++ urb->buffer[urb->actual_length++] = (crc >> 16) & 0xff;
++ urb->buffer[urb->actual_length++] = (crc >> 24) & 0xff;
++
++ break;
++ }
++ default:
++ break;
++
++ }
++ if (!urb) {
++ printk(KERN_ERR"%s: unknown encapsulation\n", __FUNCTION__);
++ rc = -EINVAL;
++ break;
++ }
++
++ // save skb for netproto_done
++ urb->privdata = (void *) skb;
++#if 0
++ printk(KERN_INFO"start_xmit: len: %d : %d data: %p\n", skb->len, urb->actual_length, urb->buffer);
++ {
++ __u8 *cp = urb->buffer;
++ int i;
++ for (i = 0; i < urb->actual_length; i++) {
++ if ((i%32) == 0) {
++ printk("\ntx[%2x] ", i);
++ }
++ printk("%02x ", *cp++);
++ }
++ printk("\n");
++ }
++#endif
++#if defined(CONFIG_USBD_NETWORK_BLAN_FERMAT)
++ if (network_private->fermat) {
++ fermat_encode(urb->buffer, urb->actual_length);
++ }
++#endif
++
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++ if ((rc = usbd_send_urb (urb))) {
++
++ printk(KERN_ERR"%s: FAILED: %d\n", __FUNCTION__, rc);
++ urb->privdata = NULL;
++ usbd_dealloc_urb (urb);
++
++ switch (rc) {
++
++ case -EINVAL:
++ case -EUNATCH:
++ printk(KERN_ERR"%s: not attached, send failed: %d\n", __FUNCTION__, rc);
++ network_private->stats.tx_errors++;
++ network_private->stats.tx_carrier_errors++;
++ netif_wake_queue (net_device);
++ break;
++
++ case -ENOMEM:
++ printk(KERN_ERR"%s: no mem, send failed: %d\n", __FUNCTION__, rc);
++ network_private->stats.tx_errors++;
++ network_private->stats.tx_fifo_errors++;
++ netif_wake_queue (net_device);
++ break;
++
++ case -ECOMM:
++ printk(KERN_ERR"%s: comm failure, send failed: %d %p\n", __FUNCTION__, rc, net_device);
++ network_private->stats.tx_dropped++;
++ break;
++
++ }
++ dev_kfree_skb_any (skb);
++ //rc = NET_XMIT_DROP; XXX this is what we should do, blows up on some 2.4.20 kernels
++ rc = 0;
++ break;
++ }
++
++ // XXX should we restart network queue
++ //printk(KERN_INFO"%s: OK: %d\n", __FUNCTION__, rc);
++ network_private->stats.tx_packets++;
++ network_private->stats.tx_bytes += len;
++
++ if ((network_private->queued_entries < network_private->max_queue_entries) &&
++ (network_private->queued_bytes < network_private->max_queue_bytes))
++ netif_wake_queue (net_device);
++
++ CATCH(not_ok) {
++ dev_kfree_skb_any (skb);
++ network_private->stats.tx_dropped++;
++ //netif_stop_queue(net_device); // XXX
++ //rc = NET_XMIT_DROP; XXX this is what we should do, blows up on some 2.4.20 kernels
++ rc = 0;
++ break;
++ }
++
++ } while (0);
++ up(&usbd_network_sem);
++ return rc;
++}
++
++
++/* network_do_ioctl - perform an ioctl call
++ *
++ * Carries out IOCTL commands for the specified network device.
++ *
++ * rp Points to an ifreq structure containing the IOCTL parameter(s).
++ * cmd The IOCTL command.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_do_ioctl (struct net_device *net_device, struct ifreq *rp, int cmd)
++{
++ return -ENOIOCTLCMD;
++}
++
++//_________________________________________________________________________________________________
++
++struct net_device Network_net_device = {
++ get_stats: network_get_stats,
++ tx_timeout: network_tx_timeout,
++ do_ioctl: network_do_ioctl,
++ set_config: network_set_config,
++ set_mac_address: network_set_mac_addr,
++ hard_start_xmit: network_hard_start_xmit,
++ change_mtu: network_change_mtu,
++ init: network_init,
++ uninit: network_uninit,
++ open: network_open,
++ stop: network_stop,
++ priv: &Usb_network_private,
++};
++
++//_________________________________________________________________________________________________
++
++
++/* network_recv - function to process an received data URB
++ *
++ * Passes received data to the network layer. Passes skb to network layer.
++ *
++ * Returns non-zero for failure.
++ */
++static __inline__ int network_recv (struct usb_network_private *network_private,
++ struct net_device *net_device, struct sk_buff *skb)
++{
++ int rc;
++#if 0
++ printk(KERN_INFO"%s: len: %x head: %p data: %p tail: %p\n", __FUNCTION__,
++ skb->len, skb->head, skb->data, skb->tail);
++ {
++ __u8 *cp = skb->data;
++ int i;
++ for (i = 0; i < skb->len; i++) {
++ if ((i%32) == 0) {
++ printk("\nrx[%2x] ", i);
++ }
++ printk("%02x ", *cp++);
++ }
++ printk("\n");
++ }
++#endif
++
++ // refuse if no device present
++ if (!netif_device_present (net_device)) {
++ printk(KERN_INFO"%s: device not present\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ // refuse if no carrier
++ if (!netif_carrier_ok (net_device)) {
++ printk(KERN_INFO"%s: no carrier\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ // refuse if the net device is down
++ if (!(net_device->flags & IFF_UP)) {
++ //printk(KERN_INFO"%s: not up net_dev->flags: %x\n", __FUNCTION__, net_device->flags);
++ network_private->stats.rx_dropped++;
++ return -EINVAL;
++ }
++
++ skb->dev = net_device;
++ skb->pkt_type = PACKET_HOST;
++ skb->protocol = eth_type_trans (skb, net_device);
++ skb->ip_summed = CHECKSUM_UNNECESSARY;
++
++ //printk(KERN_INFO"%s: len: %x head: %p data: %p tail: %p\n", __FUNCTION__,
++ // skb->len, skb->head, skb->data, skb->tail);
++
++
++ // pass it up to kernel networking layer
++ if ((rc = netif_rx (skb))) {
++ //printk(KERN_INFO"%s: netif_rx rc: %d\n", __FUNCTION__, rc);
++ }
++ network_private->stats.rx_bytes += skb->len;
++ network_private->stats.rx_packets++;
++
++ return 0;
++}
++
++//_________________________________________________________________________________________________
++
++/* network_recv_urb - callback to process a received URB
++ *
++ * Returns non-zero for failure.
++ */
++static int network_recv_urb (struct urb *urb, int rc)
++{
++ struct net_device *net_device;
++ struct usb_network_private *network_private = &Usb_network_private;
++ struct usb_function_instance *function = network_private->function;
++
++ struct sk_buff *skb = NULL;
++ int out_pkt_sz;
++
++ RETURN_EINVAL_IF(!(network_private->flags & NETWORK_ATTACHED));
++ RETURN_EINVAL_IF(!(net_device = &Network_net_device));
++
++ out_pkt_sz = usbd_endpoint_wMaxPacketSize(function, BULK_OUT, usbd_high_speed(function));
++
++#if 0
++ printk(KERN_INFO"%s: urb: %p len: %d maxtransfer: %d encap: %d\n", __FUNCTION__,
++ urb, urb->actual_length, network_private->maxtransfer, network_private->encapsulation);
++
++ {
++ __u8 *cp = urb->buffer;
++ int i;
++ for (i = 0; i < urb->actual_length; i++) {
++ if ((i%32) == 0) {
++ printk("\n[%2x] ", i);
++ }
++ printk("%02x ", *cp++);
++ }
++ printk("\n");
++ }
++#endif
++
++ THROW_IF(urb->status != RECV_OK, error);
++
++ // Is CDC active (we have received CONTROL WRITE setup packets indicating real CDC host)
++ switch (network_private->encapsulation) {
++ int len;
++ case simple_crc:
++
++ len = urb->actual_length;
++
++ // allocate skb of appropriate length, reserve 2 to align ip
++ THROW_IF(!(skb = dev_alloc_skb (len + 2)), error);
++ skb_reserve(skb, 2);
++
++#if defined(CONFIG_USBD_NETWORK_BLAN_PADAFTER)
++ {
++ /* This version simply checks for a correct CRC along the
++ * entire packet. Some UDC's have trouble with some packet
++ * sizes, this allows us to add pad bytes after the CRC.
++ */
++
++ u8 *dst = skb_put(skb, len - 1);
++ u8 *src = urb->buffer;
++ int copied;
++ u32 crc;
++
++ // XXX this should work, but the MIPS optimizer seems to get it wrong....
++ //copied = (len < out_pkt_sz) ? 0 : ((len / out_pkt_sz) - 1) * out_pkt_sz;
++
++ if (len < out_pkt_sz*2)
++ copied = 0;
++ else {
++ int pkts = ((len - out_pkt_sz) / out_pkt_sz);
++ copied = (pkts - 1) * out_pkt_sz;
++ }
++
++ len -= copied;
++ crc = CRC32_INIT;
++ for (; copied-- > 0 ; crc = COMPUTE_FCS (crc, *dst++ = *src++));
++
++ for (; (len-- > 0) && (CRC32_GOOD != crc); crc = COMPUTE_FCS (crc, *dst++ = *src++));
++
++ skb_trim(skb, skb->len - len - 4);
++
++ if (CRC32_GOOD != crc) {
++ //printk(KERN_INFO"%s: AAA frame: %03x\n", __FUNCTION__, urb->framenum);
++ THROW_IF(network_private->crc, crc_error);
++ }
++ else
++ network_private->crc = 1;
++ }
++#else
++ /*
++ * The CRC can be sent in two ways when the size of the transfer
++ * ends up being a multiple of the packetsize:
++ *
++ * |
++ * <data> <CRC><CRC><CRC><CRC>|<???> case 1
++ * <data> <NUL><CRC><CRC><CRC>|<CRC> case 2
++ * <data> <NUL><CRC><CRC><CRC><CRC>| case 3
++ * <data> <NUL><CRC><CRC><CRC>|<CRC> | case 4
++ * |
++ *
++ * This complicates CRC checking, there are four scenarios:
++ *
++ * 1. length is 1 more than multiple of packetsize with a trailing byte
++ * 2. length is 1 more than multiple of packetsize
++ * 3. length is multiple of packetsize
++ * 4. none of the above
++ *
++ * Finally, even though we always compute CRC, we do not actually throw
++ * things away until and unless we have previously seen a good CRC.
++ * This allows backwards compatibility with hosts that do not support
++ * adding a CRC to the frame.
++ *
++ */
++
++ // test if 1 more than packetsize multiple
++ if (1 == (len % out_pkt_sz)) {
++
++ // copy and CRC up to the packetsize boundary
++ u32 crc = crc32_copy(skb_put(skb, len - 1), urb->buffer, len - 1, CRC32_INIT);
++
++ // if the CRC is good then this is case 1
++ if (CRC32_GOOD != crc) {
++
++ crc = crc32_copy(skb_put(skb, 1), urb->buffer + len - 1, 1, crc);
++
++ if (CRC32_GOOD != crc) {
++ //crc_errors[len%64]++;
++ printk(KERN_INFO"%s: A CRC error %08x %03x\n", __FUNCTION__, crc, urb->framenum);
++ THROW_IF(network_private->crc, crc_error);
++ }
++ else
++ network_private->crc = 1;
++ }
++ else
++ network_private->crc = 1;
++ }
++ else {
++ u32 crc = crc32_copy(skb_put(skb, len), urb->buffer, len, CRC32_INIT);
++
++ if (CRC32_GOOD != crc) {
++ //crc_errors[len%64]++;
++ //printk(KERN_INFO"%s: CCC\n", __FUNCTION__);
++ THROW_IF(network_private->crc, crc_error);
++ }
++ else
++ network_private->crc = 1;
++ }
++ // trim IFF we are paying attention to crc
++ if (network_private->crc)
++ skb_trim(skb, skb->len - 4);
++#endif
++
++ // pass it up, free skb if non zero
++ THROW_IF(network_recv (network_private, net_device, skb), skb_error);
++
++ break;
++ default:
++ break;
++ }
++
++ // catch a simple error, just increment missed error and general error
++ CATCH(error) {
++
++ network_private->stats.rx_frame_errors++;
++ network_private->stats.rx_errors++;
++
++ // catch error where skb may need to be released
++ CATCH(skb_error) {
++
++ // catch a CRC error
++
++ // XXX We need to track whether we have seen a correct CRC, until then
++ // we ignore CRC errors.
++
++ CATCH(crc_error) {
++#if 0
++ printk(KERN_INFO"%s: urb: %p status: %d len: %d maxtransfer: %d encap: %d\n", __FUNCTION__,
++ urb, urb->status, urb->actual_length, network_private->maxtransfer,
++ network_private->encapsulation);
++
++ {
++ __u8 *cp = urb->buffer;
++ int i;
++ for (i = 0; i < urb->actual_length; i++) {
++ if ((i%32) == 0) {
++ printk("\n[%2x] ", i);
++ }
++ printk("%02x ", *cp++);
++ }
++ printk("\n");
++ }
++#endif
++ network_private->stats.rx_crc_errors++;
++ network_private->stats.rx_errors++;
++ }
++
++ // catch an overrun error
++ // (Only used if CONFIG_USBD_NETWORK_CDC is defined.)
++ //CATCH(fifo_error) {
++ // network_private->stats.rx_fifo_errors++;
++ // network_private->stats.rx_errors++;
++ //}
++
++ // if skb defined free it
++ if (skb)
++ dev_kfree_skb_any (skb);
++ }
++ network_private->stats.rx_dropped++;
++ //return -EINVAL;
++ }
++ //printk(KERN_INFO"%s: restart: %p\n", __FUNCTION__, urb);
++ return (usbd_start_recv (urb));
++}
++
++//_________________________________________________________________________________________________
++// network_urb_sent
++
++/* network_urb_sent_bulk - callback function to process a sent URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * urb Pointer to the urb that has been sent.
++ * rc Result code from the send operation.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_urb_sent_bulk (struct urb *urb, int urb_rc)
++{
++ struct sk_buff *skb;
++ struct net_device *net_device;
++ unsigned long flags;
++ struct usb_network_private *network_private = &Usb_network_private;
++ struct usb_function_instance *function = network_private->function;
++ int rc = -EINVAL;
++
++ //printk(KERN_INFO"%s: urb: %p device: %p address: %x urb_rc: %d\n", __FUNCTION__,
++ // urb, urb->device, urb->endpoint->bEndpointAddress, urb_rc);
++
++ local_irq_save(flags);
++ do {
++
++ BREAK_IF(!urb);
++ BREAK_IF(!(function = urb->function_instance));
++
++ switch (urb_rc) {
++ case SEND_FINISHED_ERROR:
++ network_private->stats.tx_errors++;
++ network_private->stats.tx_dropped++;
++ break;
++ case SEND_FINISHED_CANCELLED:
++ network_private->stats.tx_errors++;
++ network_private->stats.tx_carrier_errors++;
++ break;
++ default:
++ break;
++ }
++
++ // XXX should we zap skb first if error?
++ RETURN_EINVAL_IF(!(network_private->flags & NETWORK_CREATED));
++
++ // retrieve skb pointer and unlink from urb pointers
++ skb = (struct sk_buff *) urb->privdata;
++
++ urb->privdata = NULL;
++ usbd_dealloc_urb (urb);
++
++ // tell netproto we are done with the skb, it will test for NULL
++ // netproto_done (interface, skb, urb_rc != SEND_FINISHED_OK);
++
++ BREAK_IF(!skb);
++ BREAK_IF(!(net_device = &Network_net_device));
++
++
++ network_private->avg_queue_entries += network_private->queued_entries;
++ network_private->queued_entries--;
++ network_private->samples++;
++ network_private->jiffies += jiffies - *(time_t *) (&skb->cb);
++ network_private->queued_bytes -= skb->len;
++
++ dev_kfree_skb_any (skb);
++
++ if (netif_queue_stopped (net_device)) {
++ netif_wake_queue (net_device);
++ network_private->restarts++;
++ }
++ rc = 0;
++
++ } while (0);
++ local_irq_restore(flags);
++ return rc;
++}
++
++/* network_urb_sent_int - callback for sent URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * Returns non-zero for failure.
++ */
++static int network_urb_sent_int (struct urb *urb, int urb_rc)
++{
++ struct usb_function_instance *function;
++ struct sk_buff *skb;
++ struct net_device *net_device;
++ unsigned long flags;
++ int rc = -EINVAL;
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ //printk(KERN_INFO"%s: urb: %p device: %p address: %x urb_rc: %d\n", __FUNCTION__,
++ // urb, urb->device, urb->endpoint->bEndpointAddress, urb_rc);
++
++ local_irq_save(flags);
++ do {
++
++ BREAK_IF(!urb);
++ BREAK_IF(!(function = urb->function_instance));
++ //RETURN_EINVAL_IF(!(network_private->flags & NETWORK_ATTACHED));
++
++ //printk(KERN_INFO"%s: reseting int_urb: %p\n", __FUNCTION__, network_private->int_urb);
++ usbd_dealloc_urb (urb);
++ network_private->int_urb = NULL;
++ rc = 0;
++
++ } while (0);
++ local_irq_restore(flags);
++ return rc;
++}
++
++
++//_________________________________________________________________________________________________
++// network_recv_setup_irq
++//
++/* network_urb_received_ep0 - callback for sent URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * Returns non-zero for failure.
++ */
++static int network_urb_received_ep0 (struct urb *urb, int urb_rc)
++{
++ printk(KERN_INFO"%s: urb: %p status: %d\n", __FUNCTION__, urb, urb->status);
++
++ RETURN_EINVAL_IF (RECV_OK != urb->status);
++
++ printk(KERN_INFO"%s: %s\n", __FUNCTION__, urb->buffer);
++
++ return -EINVAL; // caller will de-allocate
++}
++
++/* network_recv_setup_irq - process a received SETUP URB
++ *
++ * Processes a received setup packet and CONTROL WRITE data.
++ * Results for a CONTROL READ are placed in urb->buffer.
++ *
++ * Returns non-zero for failure.
++ */
++static int network_recv_setup_irq (struct usb_device_request *request)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++ struct usb_function_instance *function = network_private->function;
++ struct urb *urb;
++
++
++ // Verify that this is a USB Class request per CDC specification or a vendor request.
++ RETURN_ZERO_IF (!(request->bmRequestType & (USB_REQ_TYPE_CLASS | USB_REQ_TYPE_VENDOR)));
++
++ // Determine the request direction and process accordingly
++ switch (request->bmRequestType & (USB_REQ_DIRECTION_MASK | USB_REQ_TYPE_MASK)) {
++
++ case USB_REQ_HOST2DEVICE | USB_REQ_TYPE_VENDOR:
++
++ switch (request->bRequest) {
++ case MCCI_ENABLE_CRC:
++ if (make_crc_table())
++ return -EINVAL;
++ network_private->encapsulation = simple_crc;
++ return 0;
++
++ case BELCARRA_PING:
++ //printk(KERN_INFO"%s: H2D VENDOR IP: %08x\n", __FUNCTION__, ip_addr);
++ if ((network_private->network_type == network_blan))
++ notification_schedule_bh();
++ break;
++
++#if !defined(CONFIG_USBD_NETWORK_BLAN_DO_NOT_SETTIME) || !defined(CONFIG_USBD_NETWORK_SAFE_DO_NOT_SETTIME)
++ case BELCARRA_SETTIME:
++ {
++ struct timeval tv;
++
++ // wIndex and wLength contain RFC868 time - seconds since midnight 1 jan 1900
++
++ tv.tv_sec = ntohl( request->wValue << 16 | request->wIndex);
++ tv.tv_usec = 0;
++
++ // convert to Unix time - seconds since midnight 1 jan 1970
++
++ tv.tv_sec -= RFC868_OFFSET_TO_EPOCH;
++
++ //printk(KERN_INFO"%s: H2D VENDOR TIME: %08x\n", __FUNCTION__, tv.tv_sec);
++
++ // set the time
++ do_settimeofday(&tv);
++ } break;
++#endif
++ case BELCARRA_SETIP:
++ ip_addr = ntohl( request->wValue << 16 | request->wIndex);
++ break;
++
++ case BELCARRA_SETMSK:
++ network_mask = ntohl( request->wValue << 16 | request->wIndex);
++ break;
++
++ case BELCARRA_SETROUTER:
++ router_ip = ntohl( request->wValue << 16 | request->wIndex);
++ break;
++
++ case BELCARRA_SETDNS:
++ dns_server_ip = ntohl( request->wValue << 16 | request->wIndex);
++ break;
++#ifdef CONFIG_USBD_NETWORK_BLAN_FERMAT
++ case BELCARRA_SETFERMAT:
++ network_private->fermat = 1;
++ break;
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN_HOSTNAME
++ case BELCARRA_HOSTNAME:
++ //printk(KERN_INFO"%s: HOSTNAME\n", __FUNCTION__);
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb_ep0(function, le16_to_cpu(request->wLength),
++ network_urb_received_ep0) ));
++ RETURN_ZERO_IF(!usbd_start_recv(urb)); // return if no error
++ usbd_dealloc_urb(urb); // de-alloc if error
++ return -EINVAL;
++#endif
++ }
++ return 0;
++#if 0
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_VENDOR:
++ urb->actual_length = 0;
++ switch (request->bRequest) {
++ case BELCARRA_GETMAC:
++ {
++ // copy and free the original buffer
++ memcpy(urb->buffer, Network_net_device.dev_addr, ETH_ALEN);
++ urb->actual_length = ETH_ALEN;
++ return 0;
++ }
++ }
++#endif
++ return 0;
++ default:
++ break;
++ }
++ return -EINVAL;
++}
++
++//______________________________________ Hotplug Functions ________________________________________
++
++#ifdef CONFIG_HOTPLUG
++
++#define AGENT "network_fd"
++
++/* hotplug_attach - call hotplug
++ */
++static int hotplug_attach (__u32 ip, __u32 mask, __u32 router, int attach)
++{
++ static int count = 0;
++ char *argv[3];
++ char *envp[10];
++ char ifname[20+12 + IFNAMSIZ];
++ int i;
++ char count_str[20];
++
++ RETURN_EINVAL_IF(!hotplug_path[0]);
++
++ argv[0] = hotplug_path;
++ argv[1] = AGENT;
++ argv[2] = 0;
++
++ sprintf (ifname, "INTERFACE=%s", Network_net_device.name);
++ sprintf (count_str, "COUNT=%d", count++);
++
++ i = 0;
++ envp[i++] = "HOME=/";
++ envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
++ envp[i++] = ifname;
++
++
++ if (attach) {
++ unsigned char *cp;
++ char ip_str[20+32];
++ char mask_str[20+32];
++ char router_str[20+32];
++ __u32 nh;
++
++ nh = htonl(ip);
++ cp = (unsigned char*) &nh;
++ sprintf (ip_str, "IP=%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
++
++ nh = htonl(mask);
++ cp = (unsigned char*) &nh;
++ sprintf (mask_str, "MASK=%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
++
++ nh = htonl(router);
++ cp = (unsigned char*) &nh;
++ sprintf (router_str, "ROUTER=%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
++
++ //printk (KERN_INFO "%s: attach %s %s %s\n", __FUNCTION__, ifname, ip_str, count_str);
++
++ envp[i++] = "ACTION=attach";
++ envp[i++] = ip_str;
++ envp[i++] = mask_str;
++ envp[i++] = router_str;
++ }
++ else {
++ //printk (KERN_INFO "%s: detach %s %s\n", __FUNCTION__, ifname, count_str);
++ envp[i++] = "ACTION=detach";
++ }
++
++ envp[i++] = count_str;
++ envp[i++] = 0;
++
++ return call_usermodehelper (argv[0], argv, envp);
++}
++
++
++/* hotplug_bh - bottom half handler to call hotplug script to signal ATTACH or DETACH
++ *
++ * Check connected status and load/unload as appropriate.
++ *
++ * It should not be possible for this to be called more than once at a time
++ * as it is only called via schedule_task() which protects against a second
++ * invocation.
++ */
++static void hotplug_bh (void *data)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++ struct usb_function_instance *function = network_private->function;
++
++ //printk(KERN_INFO"%s: BUS state: %d status: %d\n", __FUNCTION__, usbd_device_state(function), usbd_bus_status(function));
++
++ if (function && (USBD_OK == usbd_bus_status(function)) && (STATE_CONFIGURED == usbd_device_state(function))) {
++ if (hotplug_attached != network_private->hotplug_status) {
++ //printk(KERN_INFO"%s: ATTACH\n", __FUNCTION__);
++ network_private->hotplug_status = hotplug_attached;
++ hotplug_attach (ip_addr, network_mask, router_ip, 1);
++ }
++ }
++ else {
++ if (hotplug_detached != network_private->hotplug_status) {
++ //printk(KERN_INFO"%s: DETACH\n", __FUNCTION__);
++ network_private->hotplug_status = hotplug_detached;
++ hotplug_attach (ip_addr, network_mask, router_ip, 0);
++ }
++ }
++ MOD_DEC_USE_COUNT;
++}
++
++/* hotplug_schedule_bh - schedule a call to hotplug bottom half
++ */
++static void hotplug_schedule_bh (void)
++{
++ MOD_INC_USE_COUNT;
++ if (!schedule_task (&Usb_network_private.hotplug_bh))
++ MOD_DEC_USE_COUNT;
++}
++#endif /* CONFIG_HOTPLUG */
++
++
++//_________________________________________________________________________________________________
++
++#ifdef CONFIG_USBD_NETWORK_START_SINGLE
++#define NETWORK_START_URBS 1
++#else
++#define NETWORK_START_URBS 2
++#endif
++
++/* network_start_recv - start recv urb(s)
++ */
++void network_start_recv(struct usb_function_instance *function)
++{
++ int i;
++ for (i = 0; i < NETWORK_START_URBS; i++) {
++ struct urb *urb;
++ BREAK_IF(!(urb = usbd_alloc_urb (function, BULK_OUT,
++ usbd_endpoint_transferSize(function, BULK_OUT, usbd_high_speed(function)),
++ network_recv_urb)));
++ //printk(KERN_INFO"%s: i: %d start: %p\n", __FUNCTION__, i, urb);
++ if (usbd_start_recv(urb))
++ usbd_dealloc_urb(urb);
++ }
++}
++
++/* network_event_irg - Processes a USB event.
++ */
++static void network_event_irq (struct usb_function_instance *function, usb_device_event_t event, int data)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ switch (event) {
++
++ case DEVICE_RESET:
++ case DEVICE_DESTROY:
++ case DEVICE_BUS_INACTIVE:
++ //printk(KERN_INFO"%s: RST %x\n", __FUNCTION__, ip_addr);
++ {
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ // Return if argument is null.
++
++ // XXX flush
++
++ network_private->flags &= ~NETWORK_ATTACHED;
++ network_private->int_urb = NULL;
++
++ // Disable our net-device.
++ // Apparently it doesn't matter if we should do this more than once.
++
++ netif_stop_queue(&Network_net_device);
++ netif_carrier_off(&Network_net_device);
++
++ // If we aren't already tearing things down, do it now.
++ if (!(network_private->flags & NETWORK_DESTROYING)) {
++ network_private->flags |= NETWORK_DESTROYING;
++ //network_private->device = NULL;
++ }
++ }
++ break;
++
++ case DEVICE_CONFIGURED:
++ case DEVICE_BUS_ACTIVITY:
++ //printk(KERN_INFO"%s: CFG %x\n", __FUNCTION__, ip_addr);
++ network_private->flags |= NETWORK_ATTACHED;
++
++ if ((network_private->network_type == network_blan) && (network_private->flags & NETWORK_OPEN))
++ notification_schedule_bh();
++
++ netif_carrier_on (&Network_net_device);
++ netif_wake_queue (&Network_net_device);
++
++ network_start_recv(function);
++
++#ifdef CONFIG_USBD_NET_NFS_SUPPORT
++ if (!usb_is_configured) {
++ wake_up(&usb_netif_wq);
++ usb_is_configured = 1;
++ }
++#endif
++ break;
++
++ case DEVICE_SET_INTERFACE:
++ // XXX if CDC then we can check device->alternates[1] and see if we should
++ // enable/disable data flow.
++ // XXX verify ep0.c SET_CONFIGURATION and SET_INTERFACE implmentation are
++ // complete before using this
++ break;
++
++ default:
++ return;
++ }
++#ifdef CONFIG_HOTPLUG
++ hotplug_schedule_bh();
++#endif
++}
++
++//_________________________________________________________________________________________________
++
++/* network_function_enable - enable the function driver
++ *
++ * Called for usbd_function_enable() from usbd_register_device()
++ */
++
++static int network_function_enable (struct usb_function_instance *function)
++{
++ //printk(KERN_INFO"%s: DOWN\n", __FUNCTION__);
++ down(&usbd_network_sem);
++ MOD_INC_USE_COUNT; // QQQ Should this be _before_ the down()?
++
++ // set the network device address from the local device address
++ memcpy(Network_net_device.dev_addr, local_dev_addr, ETH_ALEN);
++
++ //Usb_network_private.bus = function->bus;
++ Usb_network_private.function = function;
++ Usb_network_private.have_interrupt = usbd_endpoint_bEndpointAddress(function, INT_IN, usbd_high_speed(function)) ? 1 : 0;
++
++ Usb_network_private.flags |= NETWORK_ENABLED;
++
++#if defined(CONFIG_USBD_NETWORK_CDC)
++ cdc_init(function);
++#endif /* CONFIG_USBD_NETWORK_CDC */
++
++#ifdef CONFIG_USBD_NETWORK_BASIC
++ basic_init(function);
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BASIC2
++ basic2_init(function);
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_SAFE
++ safe_init(function);
++#endif
++#ifdef CONFIG_USBD_NETWORK_BLAN
++ blan_init(function);
++#endif
++ up(&usbd_network_sem);
++ //printk(KERN_INFO"%s: UP\n", __FUNCTION__);
++ return 0;
++}
++
++/* network_functino_disable - disable the function driver
++ *
++ */
++static void network_function_disable (struct usb_function_instance *function)
++{
++ //printk(KERN_INFO"%s: DOWN\n", __FUNCTION__);
++ down(&usbd_network_sem);
++ Usb_network_private.flags &= ~NETWORK_ENABLED;
++ //Usb_network_private.bus = NULL;
++ Usb_network_private.function = NULL;
++ MOD_DEC_USE_COUNT; // QQQ Should this be _after_ the up()?
++ up(&usbd_network_sem);
++ //printk(KERN_INFO"%s: UP\n", __FUNCTION__);
++}
++
++struct usb_function_operations network_fd_function_ops = {
++ recv_setup_irq: network_recv_setup_irq,
++ event_irq: network_event_irq,
++ function_enable: network_function_enable,
++ function_disable: network_function_disable,
++};
++
++//_________________________________________________________________________________________________
++
++/* network_create - create and initialize network private structure
++ *
++ * Returns non-zero for failure.
++ */
++static int network_create (void)
++{
++ struct usb_network_private *network_private = &Usb_network_private;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ // Set some fields to generic defaults and register the network device with the kernel networking code
++
++ memset(&network_private->stats, 0, sizeof network_private->stats);
++
++ ether_setup (&Network_net_device);
++ RETURN_EINVAL_IF (register_netdev(&Network_net_device));
++
++ netif_stop_queue (&Network_net_device);
++ netif_carrier_off (&Network_net_device);
++ Network_net_device.flags &= ~IFF_UP;
++
++ network_private->flags |= NETWORK_CREATED;
++
++ network_private->maxtransfer = MAXFRAMESIZE + 4 + 64;
++
++ network_private->flags |= NETWORK_REGISTERED;
++
++ network_private->network_type = network_unknown;
++
++ //printk(KERN_INFO"%s: finis\n", __FUNCTION__);
++ return 0;
++}
++
++/* network_destroy - destroy network private struture
++ *
++ * Destroys the network interface referenced by the global variable @c network_private.
++ */
++static void network_destroy (void)
++{
++ if (Usb_network_private.flags & NETWORK_REGISTERED) {
++ netif_stop_queue (&Network_net_device);
++ netif_carrier_off (&Network_net_device);
++ unregister_netdev (&Network_net_device);
++ }
++ Usb_network_private.flags = 0;
++}
++
++
++//______________________________________module_init and module_exit________________________________
++
++/* hexdigit -
++ *
++ * Converts characters in [0-9A-F] to 0..15, characters in [a-f] to 42..47, and all others to 0.
++ */
++static __u8 hexdigit (char c)
++{
++ return isxdigit (c) ? (isdigit (c) ? (c - '0') : (c - 'A' + 10)) : 0;
++}
++
++/* set_address -
++ */
++void set_address(char *mac_address_str, __u8 *dev_addr)
++{
++ int i;
++ if (mac_address_str && strlen(mac_address_str)) {
++ for (i = 0; i < ETH_ALEN; i++) {
++ dev_addr[i] =
++ hexdigit (mac_address_str[i * 2]) << 4 |
++ hexdigit (mac_address_str[i * 2 + 1]);
++ }
++ }
++ else {
++ get_random_bytes(dev_addr, ETH_ALEN);
++ dev_addr[0] = (dev_addr[0] & 0xfe) | 0x02;
++ }
++}
++
++/* macstrtest -
++ */
++int macstrtest(char *mac_address_str)
++{
++ int l = 0;
++
++ if (mac_address_str) {
++ l = strlen(mac_address_str);
++ }
++ return ((l != 0) && (l != 12));
++}
++
++/* network_modinit - driver intialization
++ *
++ * Returns non-zero for failure.
++ */
++static int network_modinit (void)
++{
++ network_type_t network_type = network_unknown;
++
++ init_waitqueue_head(&usb_netif_wq);
++
++
++ printk(KERN_INFO "Copyright (c) 2002-2004 Belcarra Technologies; www.belcarra.com; sl@belcarra.com\n");
++ printk(KERN_INFO "%s: %s vendor_id: %04x product_id: %04x\n", __FUNCTION__, __usbd_module_info, vendor_id, product_id);
++
++#ifdef CONFIG_USBD_NETWORK_BLAN_FERMAT
++ //printk(KERN_INFO "%s: fermat\n", __FUNCTION__);
++ fermat_init();
++#endif
++
++#if defined(CONFIG_USBD_NETWORK_CDC)
++ if (cdc) {
++ //printk(KERN_INFO "%s: cdc\n", __FUNCTION__);
++ network_type = network_cdc;
++ }
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BASIC
++ if (basic) {
++ THROW_IF (network_type != network_unknown, select_error);
++ //printk(KERN_INFO "%s: basic\n", __FUNCTION__);
++ network_type = network_basic;
++ }
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BASIC2
++ if (basic2) {
++ THROW_IF (network_type != network_unknown, select_error);
++ //printk(KERN_INFO "%s: basic2\n", __FUNCTION__);
++ network_type = network_basic2;
++ }
++#endif
++
++#ifdef CONFIG_USBD_NETWORK_BLAN
++ if (blan) {
++ //printk(KERN_INFO "%s: blan\n", __FUNCTION__);
++ THROW_IF (network_type != network_unknown, select_error);
++ network_type = network_blan;
++ }
++#endif
++
++#if defined(CONFIG_USBD_NETWORK_CDC)
++ if (network_type == network_unknown) {
++ //printk(KERN_INFO "%s: cdc\n", __FUNCTION__);
++ network_type = network_cdc;
++ }
++#endif
++
++ // still unknown - check for other bNumConfigurations
++
++ if (network_type == network_unknown) {
++#if defined(CONFIG_USBD_NETWORK_BASIC)
++ //printk(KERN_INFO "%s: basic\n", __FUNCTION__);
++ THROW_IF (network_type != network_unknown, select_error);
++ network_type = network_basic;
++#endif
++#if defined(CONFIG_USBD_NETWORK_BASIC2)
++ //printk(KERN_INFO "%s: basic2\n", __FUNCTION__);
++ THROW_IF (network_type != network_unknown, select_error);
++ network_type = network_basic2;
++#endif
++#if defined(CONFIG_USBD_NETWORK_SAFE)
++ //printk(KERN_INFO "%s: safe\n", __FUNCTION__);
++ THROW_IF (network_type != network_unknown, select_error);
++ network_type = network_safe;
++#endif
++#if defined(CONFIG_USBD_NETWORK_BLAN)
++ //printk(KERN_INFO "%s: blan\n", __FUNCTION__);
++ THROW_IF (network_type != network_unknown, select_error);
++ network_type = network_blan;
++#endif
++ }
++
++ // sanity check
++ THROW_IF (network_type == network_unknown, select_error);
++
++ // select the function driver descriptors based on network_type
++
++ switch (network_type) {
++
++#if defined(CONFIG_USBD_NETWORK_BASIC)
++ case network_basic:
++ //printk(KERN_INFO "%s: basic\n", __FUNCTION__);
++ function_driver = &basic_function_driver;
++ break;
++#endif
++
++#if defined(CONFIG_USBD_NETWORK_BASIC2)
++ case network_basic2:
++ //printk(KERN_INFO "%s: basic2\n", __FUNCTION__);
++ function_driver = &basic2_function_driver;
++ break;
++#endif
++
++#if defined(CONFIG_USBD_NETWORK_SAFE)
++ case network_safe:
++ //printk(KERN_INFO "%s: blan bNumConfigurations: %d\n", __FUNCTION__, blan_function_driver.bNumConfigurations);
++ function_driver = &safe_function_driver;
++ break;
++#endif
++#if defined(CONFIG_USBD_NETWORK_BLAN)
++ case network_blan:
++ //printk(KERN_INFO "%s: blan bNumConfigurations: %d\n", __FUNCTION__, blan_function_driver.bNumConfigurations);
++ function_driver = &blan_function_driver;
++ break;
++#endif
++
++#if defined(CONFIG_USBD_NETWORK_CDC)
++ case network_cdc:
++ function_driver = &cdc_function_driver;
++ break;
++#endif
++ default:
++ THROW(select_error);
++ break;
++ }
++
++ strncpy(Network_net_device.name, network_type == zeroconf ? "usbz0" : (network_blan ? "usbl0" : "usbb0"), 6);
++
++
++ THROW_IF (!function_driver, select_error);
++
++ CATCH(select_error) {
++ printk(KERN_INFO "%s: configuration selection error\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++
++#ifdef CONFIG_USBD_NETWORK_EP0TEST
++ /*
++ * ep0test - test that bus interface can do ZLP on endpoint zero
++ *
++ * This will artificially force iProduct string descriptor to be
++ * exactly the same as the endpoint zero packetsize. When the host
++ * requests this string it will request it not knowing the strength
++ * and will use a max length of 0xff. The bus interface driver must
++ * send a ZLP to terminate the transaction.
++ *
++ * The iProduct descriptor is used because both the Linux and
++ * Windows usb implmentations fetch this in a default enumeration.
++ *
++ */
++ if (ep0test) {
++ switch (ep0test) {
++ case 8: function_driver->device_description->iProduct = "012"; break;
++ case 16: function_driver->device_description->iProduct = "0123456"; break;
++ case 32: function_driver->device_description->iProduct = "0123456789abcde"; break;
++ case 64: function_driver->device_description->iProduct = "0123456789abcdef0123456789abcde"; break;
++ default: printk(KERN_ERR"%s: ep0test: bad value: %d, must be one of 8, 16, 32 or 64\n",
++ __FUNCTION__, ep0test); return -EINVAL;
++ break;
++ }
++ printk(KERN_INFO"%s: ep0test: iProduct set to: %s\n", __FUNCTION__,
++ function_driver->device_description->iProduct);
++ }
++ else
++ printk(KERN_INFO"%s: ep0test: not set\n", __FUNCTION__);
++#endif /* CONFIG_USBD_NETWORK_EP0TEST */
++
++
++#ifdef CONFIG_USBD_NETWORK_ALLOW_SETID
++ //printk(KERN_INFO"%s: checking idVendor: %04x idProduct: %04x\n", __FUNCTION__, vendor_id, product_id);
++
++ if (vendor_id)
++ function_driver->idVendor = cpu_to_le16(vendor_id);
++
++ if (product_id)
++ function_driver->idProduct = cpu_to_le16(product_id);
++#endif
++
++ if ((macstrtest(local_mac_address_str) || macstrtest(remote_mac_address_str))) {
++ printk(KERN_INFO"%s: bad size %s %s\n", __FUNCTION__, local_mac_address_str, remote_mac_address_str);
++ return -EINVAL;
++ }
++
++ set_address(local_mac_address_str, local_dev_addr);
++ set_address(remote_mac_address_str, remote_dev_addr);
++
++ RETURN_EINVAL_IF(network_create());
++
++ Usb_network_private.network_type = network_type;
++
++ Usb_network_private.notification_bh.routine = notification_bh;
++ Usb_network_private.notification_bh.data = NULL;
++
++#ifdef CONFIG_HOTPLUG
++ Usb_network_private.hotplug_bh.routine = hotplug_bh;
++ Usb_network_private.hotplug_bh.data = NULL;
++#endif
++
++ memcpy(Network_net_device.dev_addr, local_dev_addr, ETH_ALEN);
++
++ THROW_IF(make_crc_table(), error);
++
++ Usb_network_private.encapsulation = simple_crc;
++
++ THROW_IF(usbd_register_function (function_driver), error);
++
++ return 0;
++
++ CATCH(error) {
++ network_destroy();
++ return -EINVAL;
++ }
++}
++
++//_________________________________________________________________________________________________
++
++/* network_modexit - driver exit
++ *
++ * Cleans up the module. Deregisters the function driver and destroys the network object.
++ */
++static void network_modexit (void)
++{
++ //printk(KERN_INFO"%s: exiting\n", __FUNCTION__);
++
++ while (Usb_network_private.notification_bh.sync) {
++ printk(KERN_ERR"%s: waiting for notificationhotplug bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++
++#ifdef CONFIG_HOTPLUG
++ while (Usb_network_private.hotplug_bh.sync) {
++ printk(KERN_ERR"%s: waiting for hotplug bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++#endif
++
++ usbd_deregister_function (function_driver);
++ network_destroy();
++ if (network_crc32_table) {
++ lkfree(network_crc32_table);
++ network_crc32_table = NULL;
++ }
++}
++
++//_________________________________________________________________________________________________
++
++module_init (network_modinit);
++module_exit (network_modexit);
++
+diff -Nru a/drivers/usbd/network_fd/network.h b/drivers/usbd/network_fd/network.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/network.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,203 @@
++/*
++ * usbd/network_fd/network.h - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef NETWORK_FD_H
++#define NETWORK_FD_H 1
++
++typedef enum network_encapsulation {
++ simple_net, simple_crc,
++} network_encapsulation_t;
++
++typedef enum network_hotplug_status {
++ hotplug_unkown,
++ hotplug_attached,
++ hotplug_detached
++} network_hotplug_status_t;
++
++typedef enum network_type {
++ network_unknown,
++ network_blan,
++ network_safe,
++ network_cdc,
++ network_basic,
++ network_basic2,
++} network_type_t;
++
++struct usb_network_private {
++
++ struct net_device_stats stats; /* network device statistics */
++
++ int flags;
++ struct usb_function_instance *function;
++ unsigned int maxtransfer;
++ rwlock_t rwlock;
++
++ network_hotplug_status_t hotplug_status;
++ network_type_t network_type;
++
++ int state;
++
++ int mtu;
++ int crc;
++#if defined(CONFIG_USBD_NETWORK_BLAN_FERMAT)
++ int fermat;
++#endif
++
++ unsigned int stopped;
++ unsigned int restarts;
++
++ unsigned int max_queue_entries;
++ unsigned int max_queue_bytes;
++
++ unsigned int queued_entries;
++ unsigned int queued_bytes;
++
++ time_t avg_queue_entries;
++
++ time_t jiffies;
++ unsigned long samples;
++
++ int have_interrupt;
++
++ struct urb *int_urb;
++
++ network_encapsulation_t encapsulation;
++
++ struct tq_struct notification_bh;
++
++#ifdef CONFIG_HOTPLUG
++ struct tq_struct hotplug_bh;
++#endif
++};
++
++// XXX this needs to be co-ordinated with rndis.c maximum's
++#define MAXFRAMESIZE 2000
++
++#if !defined(CONFIG_USBD_MAXPOWER)
++ #define CONFIG_USBD_MAXPOWER 0
++#endif
++
++#if !defined(CONFIG_USBD_MANUFACTURER)
++ #define CONFIG_USBD_MANUFACTURER "Belcarra"
++#endif
++
++
++#if !defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ #define CONFIG_USBD_SERIAL_NUMBER_STR ""
++#endif
++
++/*
++ * Lineo specific
++ */
++
++#define VENDOR_SPECIFIC_CLASS 0xff
++#define VENDOR_SPECIFIC_SUBCLASS 0xff
++#define VENDOR_SPECIFIC_PROTOCOL 0xff
++
++/*
++ * Lineo Classes
++ */
++#define LINEO_CLASS 0xff
++
++#define LINEO_SUBCLASS_BASIC_NET 0x01
++#define LINEO_SUBCLASS_BASIC_SERIAL 0x02
++
++/*
++ * Lineo Protocols
++ */
++#define LINEO_BASIC_NET_CRC 0x01
++#define LINEO_BASIC_NET_CRC_PADDED 0x02
++
++#define LINEO_BASIC_SERIAL_CRC 0x01
++#define LINEO_BASIC_SERIAL_CRC_PADDED 0x02
++
++
++/*
++ * endpoint and interface indexes
++ */
++#define BULK_OUT 0x00
++#define BULK_IN 0x01
++#define INT_IN 0x02
++#define ENDPOINTS 0x03
++
++#define COMM_INTF 0x00
++#define DATA_INTF 0x01
++
++
++/* bmDataCapabilities */
++#define BMDATA_CRC 0x01
++#define BMDATA_PADBEFORE 0x02
++#define BMDATA_PADAFTER 0x04
++#define BMDATA_FERMAT 0x08
++#define BMDATA_HOSTNAME 0x10
++
++/* bmNetworkCapabilities */
++#define BMNETWORK_SET_PACKET_OK 0x01
++#define BMNETWORK_NOBRIDGE 0x02
++
++
++/*
++ * BLAN Data Plane
++ */
++//#define CONFIG_USBD_NETWORK_PADBYTES 8
++//#define CONFIG_USBD_NETWORK_PADAFTER 1
++//#undef CONFIG_USBD_NETWORK_PADBEFORE
++//#define CONFIG_USBD_NETWORK_CRC 1
++
++
++extern __u8 network_requested_endpoints[ENDPOINTS+1];
++extern __u16 network_requested_transferSizes[ENDPOINTS+1];
++extern struct usb_network_private Usb_network_private;
++extern __u8 local_dev_addr[ETH_ALEN];
++extern __u8 remote_dev_addr[ETH_ALEN];
++
++extern struct usb_function_operations network_fd_function_ops;
++extern struct usb_network_private Usb_network_private;
++
++struct usb_class_safe_networking_mdlm_descriptor {
++ __u8 bFunctionLength; // 0x06
++ __u8 bDescriptorType; // 0x24
++ __u8 bDescriptorSubtype; // 0x13
++ __u8 bGuidDescriptorType; // 0x00
++ __u8 bmNetworkCapabilities;
++ __u8 bmDataCapabilities;
++} __attribute__ ((packed));
++
++struct usb_class_blan_networking_mdlm_descriptor {
++ __u8 bFunctionLength; // 0x07
++ __u8 bDescriptorType; // 0x24
++ __u8 bDescriptorSubtype; // 0x13
++ __u8 bGuidDescriptorType; // 0x01
++ __u8 bmNetworkCapabilities;
++ __u8 bmDataCapabilities;
++ __u8 bPad;
++} __attribute__ ((packed));
++
++
++
++
++
++#endif /* NETWORK_FD_H */
+diff -Nru a/drivers/usbd/network_fd/safe.c b/drivers/usbd/network_fd/safe.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/network_fd/safe.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,224 @@
++/*
++ * usbd/network_fd/safe.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-func.h>
++
++#include "network.h"
++
++
++#ifdef CONFIG_USBD_NETWORK_SAFE
++/* USB SAFE Configuration ******************************************************************** */
++
++/*
++ * SAFE Ethernet Configuration
++ */
++
++/* Communication Interface Class descriptors
++ */
++
++static __u8 safe_data_1[] = { 0x07, USB_DT_ENDPOINT, OUT, BULK, 0, 0x00, 0x00, };
++static __u8 safe_data_2[] = { 0x07, USB_DT_ENDPOINT, IN, BULK, 0, 0x00, 0x00, };
++static __u8 safe_comm_1[] = { 0x07, USB_DT_ENDPOINT, IN, INTERRUPT,0, 0x00, 0x0a, };
++
++static __u8 safe_class_1[] = { 0x05, CS_INTERFACE, USB_ST_HEADER, 0x10, 0x01, /* CLASS_BDC_VERSION, CLASS_BDC_VERSION */ };
++static __u8 safe_class_2[] = { 0x15, CS_INTERFACE, USB_ST_MDLM, 0x00, 0x01, /* bcdVersion, bcdVersion */
++ 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6, /* bGUID */
++ 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f, /* bGUID */ };
++
++static __u8 safe_class_3[] = { 0x06, CS_INTERFACE, USB_ST_MDLMD, 0x00, 0x00, 0x00, /* bDetailData */ };
++
++static __u8 safe_class_4[] = { 0x0d, CS_INTERFACE, USB_ST_ENF,
++ 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x05, /* 1514 maximum frame size */
++ 0x00, 0x00, 0x00 , };
++
++
++static __u8 *safe_alt_endpoints[] = {
++ (struct usb_endpoint_descriptor *) &safe_data_1,
++ (struct usb_endpoint_descriptor *) &safe_data_2,
++ (struct usb_endpoint_descriptor *) &safe_comm_1, };
++static __u8 *safe_comm_class_descriptors[] = {
++ (struct usb_generic_class_descriptor *) &safe_class_1,
++ (struct usb_generic_class_descriptor *) &safe_class_2,
++ (struct usb_generic_class_descriptor *) &safe_class_3,
++ (struct usb_generic_class_descriptor *) &safe_class_4, };
++
++u8 safe_alt_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++/* Data Interface Alternate descriptions and descriptors
++ */
++static __u8 safe_alternate_descriptor[sizeof(struct usb_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (safe_alt_endpoints) / sizeof(struct usb_endpoint_descriptor), // bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_MDLM_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00,
++};
++
++static struct usb_alternate_description safe_alternate_descriptions[] = {
++ { iInterface: CONFIG_USBD_NETWORK_SAFE_INTF,
++ interface_descriptor: (struct usb_interface_descriptor *)&safe_alternate_descriptor,
++ classes:sizeof (safe_comm_class_descriptors) / sizeof (struct usb_generic_class_descriptor *),
++ class_list: safe_comm_class_descriptors,
++ endpoints:sizeof (safe_alt_endpoints) / sizeof(struct usb_endpoint_descriptor *),
++ endpoint_list: safe_alt_endpoints,
++ endpoint_indexes: safe_alt_indexes,
++ },
++};
++
++/* Interface descriptions and descriptors
++ */
++static struct usb_interface_description safe_interfaces[] = {
++ { alternates:sizeof (safe_alternate_descriptions) / sizeof (struct usb_alternate_description),
++ alternate_list:safe_alternate_descriptions, },
++};
++
++
++/* Configuration descriptions and descriptors
++ */
++
++static __u8 safe_configuration_descriptor[sizeof(struct usb_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIG, 0x00, 0x00, // wLength
++ sizeof (safe_interfaces) / sizeof (struct usb_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ BMATTRIBUTE, BMAXPOWER,
++};
++
++struct usb_configuration_description safe_description[] = {
++ { iConfiguration: CONFIG_USBD_NETWORK_SAFE_DESC,
++ configuration_descriptor: (struct usb_configuration_descriptor *)safe_configuration_descriptor,
++ bNumInterfaces:sizeof (safe_interfaces) / sizeof (struct usb_interface_description),
++ interface_list:safe_interfaces, },
++};
++
++/* Device Description
++ */
++
++//static __u8 safe_device_descriptor[sizeof(struct usb_device_descriptor)] = {
++// 0x12, USB_DT_DEVICE,
++// 0x00, 0x02, // bcdUSB
++// COMMUNICATIONS_DEVICE_CLASS,
++// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
++//};
++static struct usb_device_descriptor safe_device_descriptor = {
++ bLength: sizeof(struct usb_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++
++static struct usb_endpoint_request safe_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_BULK, MAXFRAMESIZE + 48, MAXFRAMESIZE + 512, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT, 16, 64, },
++ { 0, },
++};
++
++struct usb_device_description safe_device_description = {
++ device_descriptor: &safe_device_descriptor,
++ iManufacturer: CONFIG_USBD_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_USBD_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_USBD_NO_SERIAL_NUMBER) && defined(CONFIG_USBD_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_USBD_SERIAL_NUMBER_STR,
++#endif
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: safe_endpoint_requests,
++};
++
++void safe_init (struct usb_function_instance *function)
++{
++ struct usb_class_ethernet_networking_descriptor *ethernet;
++ int len = 0;
++ char buf[255];
++
++ buf[0] = 0;
++
++ safe_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 3 : 2;
++
++ // Update the iMACAddress field in the ethernet descriptor
++ {
++ char address_str[14];
++ snprintf(address_str, 13, "%02x%02x%02x%02x%02x%02x",
++ remote_dev_addr[0], remote_dev_addr[1], remote_dev_addr[2],
++ remote_dev_addr[3], remote_dev_addr[4], remote_dev_addr[5]);
++ if ((ethernet = (struct usb_class_ethernet_networking_descriptor *)safe_class_4)) {
++ if (ethernet->iMACAddress) {
++ usbd_dealloc_string(ethernet->iMACAddress);
++ }
++ ethernet->iMACAddress = usbd_alloc_string(address_str);
++ }
++ }
++
++
++#ifdef CONFIG_USBD_NETWORK_SAFE_PADBEFORE
++ safe_class_3[5] |= BMDATA_PADBEFORE;
++ len += sprintf(buf + len, "PADBEFORE: %02x ", safe_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_SAFE_CRC
++ safe_class_3[5] |= BMDATA_CRC;
++ len += sprintf(buf + len, "CRC: %02x ", safe_class_3[5]);
++#endif
++#ifdef CONFIG_USBD_NETWORK_SAFE_NOBRIDGE
++ safe_class_3[4] |= BMNETWORK_NOBRIDGE;
++ len += sprintf(buf + len, "NOBRIDGE: %02x ",safe_class_3[4]);
++#endif
++ if (strlen(buf))
++ printk(KERN_INFO"%s: %s\n", __FUNCTION__, buf);
++
++}
++
++struct usb_function_driver safe_function_driver = {
++ name: "network-SAFE",
++ fops: &network_fd_function_ops,
++ device_description: &safe_device_description,
++ bNumConfigurations: sizeof (safe_description) / sizeof (struct usb_configuration_description),
++ configuration_description: safe_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_USBD_NETWORK_BCDDEVICE),
++};
++#endif /* CONFIG_USBD_NETWORK_SAFE */
++
+diff -Nru a/drivers/usbd/trace.c b/drivers/usbd/trace.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/trace.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,509 @@
++/*
++ * usbd/trace.c
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2002 Lineo
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/version.h>
++
++//EXPORT_NO_SYMBOLS;
++
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/delay.h>
++
++#include <linux/proc_fs.h>
++#include <linux/vmalloc.h>
++
++#include <asm/atomic.h>
++#include <asm/io.h>
++
++#include <linux/proc_fs.h>
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,6)
++#define USE_ADD_DEL_TIMER_FOR_USBADDR_CHECK 1
++#include <linux/timer.h>
++#else
++#undef USE_ADD_DEL_TIMER_FOR_USBADDR_CHECK
++#include <linux/tqueue.h>
++#endif
++
++#include <linux/pci.h>
++#include <linux/cache.h>
++
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++#include <asm/dma.h>
++#include <asm/mach/dma.h>
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/hardware.h>
++#include <asm/types.h>
++#endif
++
++#if defined(CONFIG_SOC_AU1X00) || \
++ defined(CONFIG_MIPS_AU1X00) || \
++ defined(CONFIG_CPU_AU1X00) || \
++ defined(CONFIG_MIPS_AU1000) || \
++ defined(CONFIG_MIPS_PB1500) || \
++ defined(CONFIG_MIPS_PB1100)
++
++#include <asm/au1000.h>
++#include <asm/au1000_dma.h>
++#include <asm/mipsregs.h>
++
++#endif /* defined(..) */
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#include <asm/arch/timers.h>
++#include <asm/arch/hardware.h>
++#endif /* defined(CONFIG_ARCH_SAMSUNG) */
++
++#if defined(CONFIG_ARCH_MX1ADS)
++#include "dbmx1_bi/dbmx1.h"
++#endif /* defined(CONFIG_ARCH_MX1ADS) */
++
++#include <asm/uaccess.h>
++#include <asm/io.h>
++#include <asm/pgtable.h>
++#include <asm/pgalloc.h>
++
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-func.h"
++#include "usbd-bus.h"
++
++#include "trace.h"
++#include "usbd-bi.h"
++
++
++int trace_first;
++int trace_next;
++trace_t *traces;
++
++#if defined(CONFIG_USBD_BI_REGISTER_TRACE) && defined(CONFIG_PROC_FS)
++
++trace_t *TRACE_NEXT(trace_types_t trace_type)
++{
++ trace_t *p;
++
++ p = traces + trace_next;
++
++ #if defined(CONFIG_ARCH_SA1100) || \
++ defined (CONFIG_ARCH_PXA)
++
++ p->oscr = OSCR;
++
++ #elif defined(CONFIG_SOC_AU1X00) || \
++ defined(CONFIG_MIPS_AU1X00) || \
++ defined(CONFIG_CPU_AU1X00) || \
++ defined(CONFIG_MIPS_AU1000) || \
++ defined(CONFIG_MIPS_PB1500) || \
++ defined(CONFIG_MIPS_PB1100)
++
++ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
++ p->cp0_count = __read_32bit_c0_register(CP0_COUNT);
++ #else
++ p->cp0_count = read_c0_count();
++ #endif
++
++ #elif defined(CONFIG_ARCH_SAMSUNG)
++ p->tcnt1 = *(volatile u32 *)TCNT1;
++ #else
++ p->jiffies = jiffies;
++ #endif
++
++ #if defined(CONFIG_SOC_AU1X00) || \
++ defined(CONFIG_MIPS_AU1X00) || \
++ defined(CONFIG_CPU_AU1X00) || \
++ defined(CONFIG_MIPS_AU1000) || \
++ defined(CONFIG_MIPS_PB1500) || \
++ defined(CONFIG_MIPS_PB1100)
++ //p->sofs = au_readl(USBD_FRAMENUM);
++ #endif
++
++ #if defined(CONFIG_ARCH_MX1ADS)
++ p->sofs = USBD_FRAME & 0x3ff;
++ #endif
++
++ p->interrupts = udc_interrupts;
++ p->trace_type = trace_type;
++
++ trace_next++;
++ trace_next = (trace_next == TRACE_MAX) ? 0 : trace_next;
++
++ if (trace_next == trace_first) {
++ trace_first++;
++ trace_first = (trace_first == TRACE_MAX) ? 0 : trace_first;
++ }
++
++ return p;
++}
++
++/* Proc Filesystem *************************************************************************** */
++
++static __inline__ char *nullchk(char *s)
++{
++ return s ? s : "(NULL)";
++}
++/* *
++ * trace_proc_read - implement proc file system read.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Standard proc file system read function.
++ */
++static ssize_t trace_proc_read (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++ int oindex;
++ int previous;
++
++ #ifdef MODULE
++ MOD_INC_USE_COUNT;
++ #endif
++ // get a page, max 4095 bytes of data...
++ if (!(page = get_free_page (GFP_KERNEL))) {
++
++ #ifdef MODULE
++ MOD_DEC_USE_COUNT;
++ #endif
++ return -ENOMEM;
++ }
++
++ len = 0;
++ oindex = index = (*pos)++;
++
++ if (index == 0) {
++ #if defined(CONFIG_ARCH_SAMSUNG)
++ len += sprintf ((char *) page + len, " Index Ints Ticks [%d]\n", CONFIG_USBD_SMDK2500_BCLOCK );
++ #else
++ len += sprintf ((char *) page + len, " Index Ints Ticks\n");
++ #endif
++ }
++
++ index += trace_first;
++ if (index >= TRACE_MAX) {
++ index -= TRACE_MAX;
++ }
++ previous = (index) ? (index - 1) : (TRACE_MAX - 1);
++
++ //printk(KERN_INFO"first: %d next: %d index: %d %d prev: %d\n", trace_first, trace_next, oindex, index, previous);
++
++ if (
++ ((trace_first < trace_next) && (index >= trace_first) && (index < trace_next)) ||
++ ((trace_first > trace_next) && ((index < trace_next) || (index >= trace_first)))
++ )
++ {
++
++ #if defined(CONFIG_SOC_AU1X00) || \
++ defined(CONFIG_MIPS_AU1X00) || \
++ defined(CONFIG_CPU_AU1X00) || \
++ defined(CONFIG_MIPS_AU1000) || \
++ defined(CONFIG_MIPS_PB1500) || \
++ defined(CONFIG_MIPS_PB1100)
++
++ u32 ticks = 0;
++
++ #elif defined(CONFIG_ARCH_SAMSUNG)
++ u32 ticks = 0;
++ #elif defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ u32 ticks = 0;
++ u64 jifs = 0;
++ #else
++ u64 jifs = 0;
++ #endif
++
++ trace_t *p = traces + index;
++ unsigned char *cp;
++ int skip = 0;
++
++ if (oindex > 0) {
++ trace_t *o = traces + previous;
++
++ #if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ /*
++ * oscr is 3.6864 Mhz free running counter,
++ *
++ * 1/3.6864 = .2712
++ * 60/221 = .2714
++ *
++ */
++ if (o->oscr) {
++ ticks = (p->oscr > o->oscr) ? (p->oscr - o->oscr) : (o->oscr - p->oscr) ;
++ ticks = (ticks * 60) / 221;
++ }
++
++ #elif defined(CONFIG_SOC_AU1X00) || \
++ defined(CONFIG_MIPS_AU1X00) || \
++ defined(CONFIG_CPU_AU1X00) || \
++ defined(CONFIG_MIPS_AU1000) || \
++ defined(CONFIG_MIPS_PB1500) || \
++ defined(CONFIG_MIPS_PB1100)
++ /*
++ * cp0_count is incrementing timer at system clock
++ */
++ if (o->cp0_count) {
++ ticks = (p->cp0_count > o->cp0_count) ?
++ (p->cp0_count - o->cp0_count) : (o->cp0_count - p->cp0_count) ;
++ ticks = ticks / CONFIG_USBD_AU1X00_SCLOCK;
++ }
++ #elif defined(CONFIG_ARCH_SAMSUNG)
++ /*
++ * tcnt1 is a count-down timer running at the system bus clock
++ * The divisor must be set as a configuration value, typically 66 or 133.
++ */
++ if (o->tcnt1) {
++ ticks = (p->tcnt1 < o->tcnt1) ? (o->tcnt1 - p->tcnt1) : (p->tcnt1 - o->tcnt1) ;
++ ticks /= CONFIG_USBD_SMDK2500_BCLOCK;
++ }
++ #else
++ if (o->jiffies) {
++ jifs = p->jiffies - traces[previous].jiffies;
++ }
++ #endif
++
++ if (o->interrupts != p->interrupts) {
++ skip++;
++ }
++ }
++
++ //printk(KERN_INFO"index: %d interrupts: %d\n", index, p->interrupts);
++ len += sprintf ((char *) page + len, "%s%6d %8d ", skip?"\n":"", index, p->interrupts);
++
++ #if defined(CONFIG_SOC_AU1X00) || \
++ defined(CONFIG_MIPS_AU1X00) || \
++ defined(CONFIG_CPU_AU1X00) || \
++ defined(CONFIG_MIPS_AU1000) || \
++ defined(CONFIG_MIPS_PB1500) || \
++ defined(CONFIG_MIPS_PB1100) || \
++ defined(CONFIG_ARCH_SA1100) || \
++ defined(CONFIG_ARCH_PXA)
++
++ if (ticks > 1024*1024) {
++ len += sprintf ((char *) page + len, "%8dM ", ticks>>20);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%8d ", ticks);
++ }
++
++ #elif defined(CONFIG_ARCH_SAMSUNG)
++ //len += sprintf ((char *) page + len, "%8u ", p->jiffies);
++ //len += sprintf ((char *) page + len, "%8u ", p->tcnt0);
++ len += sprintf ((char *) page + len, "%8u ", p->tcnt1);
++ if (ticks > 1024*1024) {
++ len += sprintf ((char *) page + len, "%8dM ", ticks>>20);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%8d ", ticks);
++ }
++ #else
++ if (jifs > 1024) {
++ len += sprintf ((char *) page + len, "%4d ", (int)jifs>>20);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%4d ", (int)jifs);
++ }
++ #endif
++ #if defined(CONFIG_ARCH_MX1ADS)
++ len += sprintf ((char *) page + len, "%6d ", (int)p->sofs);
++ #endif
++
++ switch (p->trace_type) {
++ case trace_msg:
++ len += sprintf ((char *) page + len, " -- ");
++ len += sprintf ((char *) page + len, p->trace.msg.msg);
++ break;
++
++ case trace_w:
++ len += sprintf ((char *) page + len, " --> ");
++ len += sprintf ((char *) page + len, "[%8x] W %s", p->trace.msg32.val, nullchk(p->trace.msg32.msg));
++ break;
++
++ case trace_r:
++ len += sprintf ((char *) page + len, "<-- ");
++ len += sprintf ((char *) page + len, "[%8x] R %s", p->trace.msg32.val, nullchk(p->trace.msg32.msg));
++ break;
++
++ case trace_msg32:
++ len += sprintf ((char *) page + len, " -- ");
++ len += sprintf ((char *) page + len, p->trace.msg32.msg, p->trace.msg32.val);
++ break;
++
++ case trace_msg16:
++ len += sprintf ((char *) page + len, " -- ");
++ len += sprintf ((char *) page + len, p->trace.msg16.msg, p->trace.msg16.val0, p->trace.msg16.val1);
++ break;
++
++ case trace_msg8:
++ len += sprintf ((char *) page + len, " -- ");
++ len += sprintf ((char *) page + len, p->trace.msg8.msg,
++ p->trace.msg8.val0, p->trace.msg8.val1, p->trace.msg8.val2, p->trace.msg8.val3);
++ break;
++
++ case trace_setup:
++ cp = (unsigned char *)&p->trace.setup;
++ len += sprintf ((char *) page + len,
++ " -- request [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++ break;
++
++ case trace_recv:
++ case trace_sent:
++ cp = (unsigned char *)&p->trace.sent;
++ len += sprintf ((char *) page + len,
++ "%s %s [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ ( p->trace_type == trace_recv)?"<-- ":" -->",
++ ( p->trace_type == trace_recv)?"recv":"sent",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++ break;
++ }
++ len += sprintf ((char *) page + len, "\n");
++ }
++
++ if ((len > count) || (len == 0))
++ len = -EINVAL;
++
++ else if (len > 0 && copy_to_user (buf, (char *) page, len))
++ len = -EFAULT;
++
++ free_page (page);
++ MOD_DEC_USE_COUNT;
++ return len;
++}
++
++/* *
++ * trace_proc_write - implement proc file system write.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Proc file system write function, used to signal monitor actions complete.
++ * (Hotplug script (or whatever) writes to the file to signal the completion
++ * of the script.) An ugly hack.
++ */
++static ssize_t trace_proc_write (struct file *file, const char *buf, size_t count, loff_t * pos)
++{
++ return count;
++}
++
++static struct file_operations trace_proc_operations_functions = {
++ read:trace_proc_read,
++ write:trace_proc_write,
++};
++
++int trace_reinit (void)
++{
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++ //trace_first = trace_next = 0;
++ return 0;
++}
++
++/**
++ * udc_request_udc_io - request UDC io region
++ *
++ * Return non-zero if not successful.
++ */
++int trace_init (void)
++{
++ struct proc_dir_entry *p;
++ trace_first = trace_next = 0;
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ if (!(traces = vmalloc(sizeof(trace_t) * TRACE_MAX))) {
++ printk(KERN_ERR"BITRACE malloc failed %p %d\n", traces, sizeof(trace_t) * TRACE_MAX);
++ return -EINVAL;
++ }
++
++ memset(traces, 0, sizeof(trace_t) * TRACE_MAX);
++
++ TRACE_MSG("init");
++ TRACE_MSG("test");
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry ("bitrace", 0, 0)) == NULL)
++ printk(KERN_INFO"BITRACE PROC FS failed\n");
++ else
++ p->proc_fops = &trace_proc_operations_functions;
++
++ #if defined(CONFIG_ARCH_SAMSUNG)
++ *(volatile u32 *)TMOD |= 0x3 << 3;
++ #endif
++ return 0;
++}
++
++/**
++ * udc_release_io - release UDC io region
++ */
++void trace_exit (void)
++{
++ {
++ unsigned long flags;
++ local_irq_save (flags);
++ remove_proc_entry ("bitrace", NULL);
++ if (traces) {
++ trace_t *p = traces;
++ traces = 0;
++ vfree(p);
++ }
++ local_irq_restore (flags);
++ }
++}
++
++#else
++int trace_reinit (void)
++{
++ return 0;
++}
++
++int trace_init (void)
++{
++ return 0;
++}
++
++void trace_exit (void)
++{
++ return;
++}
++#endif
++
++/* End of FILE */
++
++
++//EXPORT_SYMBOL(trace_first);
++//EXPORT_SYMBOL(trace_next);
++//EXPORT_SYMBOL(traces);
++
+diff -Nru a/drivers/usbd/trace.h b/drivers/usbd/trace.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/trace.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,270 @@
++/*
++ * usbd/trace.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2002 Lineo
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#ifndef CONFIG_USBD_SMDK2500_BCLOCK
++#define CONFIG_USBD_SMDK2500_BCLOCK 66
++#endif
++#endif
++
++
++typedef enum trace_int_types {
++ trace_int_udc, trace_int_ep0, trace_int_in, trace_int_out, trace_int_int
++} trace_int_types_t;
++
++typedef struct trace_int {
++ u32 last;
++ u32 total;
++ u32 samples;
++} trace_int_t;
++
++
++typedef enum trace_types {
++ trace_setup, trace_msg, trace_msg32, trace_msg16, trace_msg8, trace_recv, trace_sent, trace_w, trace_r
++} trace_types_t;
++
++
++typedef struct trace_regs32 {
++ u32 reg;
++ char * msg;
++} trace_regs32_t;
++
++
++typedef struct trace_msg {
++ char *msg;
++} trace_msg_t;
++
++typedef struct trace_msg32 {
++ u32 val;
++ char *msg;
++} trace_msg32_t;
++
++typedef struct trace_msg16 {
++ u16 val0;
++ u16 val1;
++ char *msg;
++} trace_msg16_t;
++
++typedef struct trace_msg8 {
++ u8 val0;
++ u8 val1;
++ u8 val2;
++ u8 val3;
++ char *msg;
++} trace_msg8_t;
++
++
++typedef struct trace {
++ trace_types_t trace_type;
++ u32 interrupts;
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ u32 oscr;
++
++#elif defined(CONFIG_SOC_AU1X00) || defined(CONFIG_MIPS_AU1X00) || defined(CONFIG_CPU_AU1X00) || defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100)
++
++ u32 cp0_count;
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ //u32 tcnt0;
++ u32 tcnt1;
++ //u64 jiffies;
++#else
++ u64 jiffies;
++#endif
++#if defined(CONFIG_SOC_AU1X00) || defined(CONFIG_MIPS_AU1X00) || defined(CONFIG_CPU_AU1X00) || defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_ARCH_MX1ADS)
++ u64 sofs;
++#endif
++ union {
++ trace_msg_t msg;
++ trace_msg8_t msg8;
++ trace_msg16_t msg16;
++ trace_msg32_t msg32;
++
++ struct usb_device_request setup;
++ unsigned char recv[8];
++ unsigned char sent[8];
++
++ } trace;
++
++} trace_t;
++
++
++#define TRACE_MAX 10000
++
++extern int trace_first;
++extern int trace_next;
++
++extern trace_int_t *trace_ints;
++extern trace_t *traces;
++
++#ifdef CONFIG_USBD_BI_REGISTER_TRACE
++
++trace_t *TRACE_NEXT(trace_types_t trace_type);
++
++static __inline__ void TRACE_SETUP(struct usb_device_request *setup)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_setup);
++ p->trace_type = trace_setup;
++ memcpy(&p->trace.setup, setup, sizeof(struct usb_device_request));
++ }
++}
++
++static __inline__ void TRACE_MSG(char *msg)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_msg);
++ p->trace.msg.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_W(char *msg, u32 val)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_w);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_R(char *msg, u32 val)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_r);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_MSG32(char *msg, u32 val)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_msg32);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_MSG16(char *msg, u16 val0, u16 val1)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_msg16);
++ p->trace.msg16.val0 = val0;
++ p->trace.msg16.val1 = val1;
++ p->trace.msg16.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_MSG8(char *msg, u8 val0, u8 val1, u8 val2, u8 val3)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_msg8);
++ p->trace.msg8.val0 = val0;
++ p->trace.msg8.val1 = val1;
++ p->trace.msg8.val2 = val2;
++ p->trace.msg8.val3 = val3;
++ p->trace.msg8.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_RECV(unsigned char *cp)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_recv);
++ memcpy(&p->trace.recv, cp, 8);
++ }
++}
++
++static __inline__ void TRACE_RECVN(unsigned char *cp, int bytes)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_recv);
++ memset(&p->trace.recv, 0, 8);
++ memcpy(&p->trace.recv, cp, bytes);
++ }
++}
++
++static __inline__ void TRACE_SENT(unsigned char *cp)
++{
++ if (traces) {
++ trace_t *p = TRACE_NEXT(trace_sent);
++ memcpy(&p->trace.sent, cp, 8);
++ }
++}
++
++#else
++
++static __inline__ void TRACE_SETUP(struct usb_device_request *setup)
++{
++}
++
++static __inline__ void TRACE_IRQS(u32 cr, u32 sr)
++{
++}
++
++static __inline__ void TRACE_RECV(unsigned char *cp)
++{
++}
++
++static __inline__ void TRACE_SENT(unsigned char *cp)
++{
++}
++
++static __inline__ void TRACE_W(char *msg, u32 val)
++{
++}
++
++static __inline__ void TRACE_R(char *msg, u32 val)
++{
++}
++
++static __inline__ void TRACE_MSG(char *msg)
++{
++}
++
++static __inline__ void TRACE_MSG32(char *msg, u32 val)
++{
++}
++
++static __inline__ void TRACE_MSG16(char *msg, u16 val0, u16 val1)
++{
++}
++
++static __inline__ void TRACE_MSG8(char *msg, u8 val0, u8 val1, u8 val2, u8 vale)
++{
++}
++static __inline__ void TRACE_RECVN(unsigned char *cp, int bytes)
++{
++}
++
++#endif
++
++int trace_init (void);
++int trace_reinit (void);
++void trace_exit (void);
++
+diff -Nru a/drivers/usbd/udc.h b/drivers/usbd/udc.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/udc.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,48 @@
++/*
++ * usbd/udc.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
++ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ * See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along with this program; if
++ * not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/init.h>
++#include <linux/delay.h>
++#include <asm/atomic.h>
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/types.h>
++#include <asm/uaccess.h>
++#include <asm/io.h>
++
++#include <usbd-export.h>
++#include <usbd-build.h>
++#include <usbd-chap9.h>
++#include <usbd-mem.h>
++#include <usbd.h>
++#include <usbd-bus.h>
++#include <trace.h>
++#include <usbd-bi.h>
++
+diff -Nru a/drivers/usbd/usbd-admin.h b/drivers/usbd/usbd-admin.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-admin.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,61 @@
++/*
++ * usbd/usbd-admin.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++/*
++ * This defines the public interface to administer the USB Device Software.
++ *
++ * Specifically it allows the USB Device software to be:
++ *
++ * enabled enable a specific function driver for use
++ * disabled disable the USB Device Software
++ *
++ * disconnected disable the USB Pullup Resistor (also known as soft-connect)
++ * connected enable the USB Pullup Resistor
++ *
++ * pm_off perform required functions for Power Management off
++ * pm_on perform required functions for Power Management on
++ *
++ *
++ */
++
++int usbd_enable(char *);
++int usbd_enable_irq(char *);
++int usbd_disable(char *);
++int usbd_disable_irq(char *);
++
++int usbd_disconnect(char *);
++int usbd_connect(char *);
++int usbd_pm_on(char *);
++int usbd_pm_off(char *);
++
++#ifdef CONFIG_USBD_DEPRECATED
++int usbd_load(char *);
++int usbd_unload(char *);
++int usbd_replug(char *);
++int usbd_unplug(char *);
++#endif
++
+diff -Nru a/drivers/usbd/usbd-bi.c b/drivers/usbd/usbd-bi.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-bi.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,753 @@
++/*
++ * usbd/usbd-bi.c - USB Bus Interface Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ * This program is free software; you can redistribute it and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
++ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ * See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along with this program; if
++ * not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ * Notes
++ *
++ * 1. The usbd-bi layer has be re-implemented to re-factor the UDC layer in a way to
++ * simplify implementation of UDC drivers. As much of the complexity of dealing with the middle
++ * layers and buffer (urb) handling is provided for in the common bi layer.
++ *
++ * 2. TODO The udc interface will be further modified to allow the UDC to export a block of
++ * function pointers for the common bi layer to use. This will allow the common layer to
++ * implement default operations where the UDC does not provide an function. For example many UDC
++ * drivers do not provide full support for cable detection and usb pullup control. If these
++ * routines are not provided the common layer will supply defaults. This eliminates a reasonably
++ * larger amount of effectively unused code from many of the udc drivers.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++#include <linux/init.h>
++#include <linux/ctype.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <asm/uaccess.h>
++
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-bus.h"
++#include "usbd-func.h"
++#include "trace.h"
++#include "usbd-bi.h"
++#include "usbd-admin.h"
++
++#ifdef MODULE
++static char *serial_number_str;
++MODULE_PARM (serial_number_str, "s");
++MODULE_PARM_DESC (serial_number_str, "Serial Number");
++#else
++static char *serial_number_str;
++#endif
++
++struct usb_bus_instance *usbd_bus;
++int have_cable_irq;
++
++/* ******************************************************************************************* */
++
++int bi_attached (struct usb_bus_instance *bus)
++{
++ return udc_ops.attached ? udc_ops.attached () : 1;
++}
++
++int bi_connected (struct usb_bus_instance *bus)
++{
++ return udc_ops.connected ? udc_ops.connected () : 1;
++}
++
++int bi_disconnect (struct usb_bus_instance *bus, char *arg)
++{
++ RETURN_EINVAL_IF (in_interrupt ());
++ if (udc_ops.disconnect) udc_ops.disconnect ();
++ return 0;
++}
++
++int bi_connect (struct usb_bus_instance *bus, char *arg)
++{
++ RETURN_EINVAL_IF (in_interrupt ());
++ if (udc_ops.connect) udc_ops.connect ();
++ return 0;
++}
++
++int bi_request_endpoints(struct usb_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usb_endpoint_request *requestedEndpoints)
++{
++ int i;
++ RETURN_EINVAL_IF (udc_ops.request_endpoints(endpoint_map_array, endpointsRequested, requestedEndpoints));
++ for (i = 0; i < endpointsRequested; i++) {
++ struct usb_endpoint_map *endpoint_map = endpoint_map_array + i;
++ TRACE_MSG8 ("address: %02x physical: %02x request: %02x size: %04x",
++ endpoint_map->bEndpointAddress[0], endpoint_map->physicalEndpoint[0],
++ endpoint_map->bmAttributes[0], endpoint_map->wMaxPacketSize[0]);
++ }
++ return 0;
++}
++int bi_set_endpoints(int endpointsRequested, struct usb_endpoint_map *endpoint_map_array)
++{
++ return udc_ops.set_endpoints ? udc_ops.set_endpoints(endpointsRequested, endpoint_map_array) : 0;
++}
++
++/* ******************************************************************************************* */
++/* bi_endpoint_halted - check if endpoint halted
++ * Used by the USB Device Core to check endpoint halt status.
++ */
++int bi_endpoint_halted (struct usb_bus_instance *bus, int endpoint_index)
++{
++ return udc_ops.endpoint_halted ? udc_ops.endpoint_halted(endpoint_index) : 0;
++}
++
++/* bi_device_feature - handle set/clear feature requests
++ * Used by the USB Device Core to check endpoint halt status.
++ */
++int bi_device_feature (struct usb_bus_instance *bus, int endpoint_index, int flag)
++{
++ return 0;
++}
++
++/* bi_disable_endpoints - disable udc and all endpoints
++ */
++static void bi_disable_endpoints (struct usb_bus_instance *bus)
++{
++ int i;
++ RETURN_IF (!bus || !bus->endpoint_array);
++ for (i = 1; i < udc_ops.max_endpoints; i++) {
++ struct usb_endpoint_instance *endpoint = (bus->endpoint_array + i);
++ CONTINUE_IF (!endpoint);
++ usbd_flush_endpoint (endpoint);
++ }
++}
++
++
++/* bi_device_event_irq - handle generic bus event
++ * Called by usb core layer to inform bus of an event.
++ */
++int bi_device_event_irq (struct usb_bus_instance *bus, usb_device_event_t event, int data)
++{
++ int epn;
++ int endpointsRequested = bus->function_instance->endpointsRequested;
++ struct usb_endpoint_map *endpoint_map_array = bus->function_instance->endpoint_map_array;
++
++ TRACE_MSG32 ("EVENT %x", event);
++ switch (event) {
++ case DEVICE_UNKNOWN:
++ break;
++
++ case DEVICE_INIT:
++ TRACE_MSG ("EVENT INIT");
++ break;
++
++ case DEVICE_CREATE:
++ TRACE_MSG ("EVENT CREATE");
++ bi_disable_endpoints (bus);
++ if (udc_ops.enable) udc_ops.enable ();
++ if (udc_ops.suspended_interrupts) udc_ops.suspended_interrupts ();
++ break;
++
++ case DEVICE_HUB_CONFIGURED:
++ TRACE_MSG ("EVENT HUB_CONFIGURED");
++ bi_connect (usbd_bus, NULL);
++ break;
++
++ case DEVICE_RESET:
++ TRACE_MSG ("EVENT RESET");
++ if (udc_ops.set_address) udc_ops.set_address (0);
++ if (udc_ops.reset_ep) udc_ops.reset_ep (0);
++ if (udc_ops.suspended_interrupts) udc_ops.suspended_interrupts ();
++ bi_disable_endpoints (bus);
++ break;
++
++ case DEVICE_ADDRESS_ASSIGNED:
++ TRACE_MSG ("EVENT ADDRESSED");
++ if (udc_ops.set_address) udc_ops.set_address (data);
++ if (udc_ops.all_interrupts) udc_ops.all_interrupts ();
++ break;
++
++ case DEVICE_CONFIGURED:
++ TRACE_MSG ("EVENT CONFIGURED");
++ // iterate across the physical endpoint instance array to enable the endpoints
++ if (udc_ops.setup_ep)
++ for (epn = 1; epn < bus->endpoints; epn++)
++ udc_ops.setup_ep (epn, bus->endpoint_array + epn);
++ return 0;
++
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG ("EVENT DE-CONFIGURED");
++ break;
++
++ case DEVICE_SET_INTERFACE:
++ TRACE_MSG ("EVENT SET INTERFACE");
++ break;
++
++ case DEVICE_SET_FEATURE:
++ TRACE_MSG ("EVENT SET FEATURE");
++ break;
++
++ case DEVICE_CLEAR_FEATURE:
++ TRACE_MSG ("EVENT CLEAR FEATURE");
++ break;
++
++ case DEVICE_BUS_INACTIVE:
++ TRACE_MSG ("EVENT INACTIVE");
++ if (udc_ops.suspended_interrupts) udc_ops.suspended_interrupts (); // disable suspend interrupt
++ if (bi_attached (usbd_bus))
++ usbd_bus_event_irq (bus, DEVICE_RESET, 0);
++ break;
++
++ case DEVICE_BUS_ACTIVITY:
++ TRACE_MSG ("EVENT ACTIVITY");
++ if (udc_ops.all_interrupts) udc_ops.all_interrupts (); // enable suspend interrupt
++ break;
++
++ case DEVICE_POWER_INTERRUPTION:
++ TRACE_MSG ("POWER INTERRUPTION");
++ break;
++
++ case DEVICE_HUB_RESET:
++ TRACE_MSG ("HUB RESET");
++ break;
++
++ case DEVICE_DESTROY:
++ TRACE_MSG ("DEVICE DESTROY");
++ bi_disconnect (usbd_bus, NULL);
++ bi_disable_endpoints (bus);
++ if (udc_ops.disable_interrupts) udc_ops.disable_interrupts ();
++ if (udc_ops.disable) udc_ops.disable ();
++ break;
++
++ case DEVICE_CLOSE:
++ break;
++ }
++ return 0;
++}
++
++
++/* bi_start_endpoint_in
++ */
++int bi_start_endpoint_in (struct usb_bus_instance *bus, struct usb_endpoint_instance *endpoint)
++{
++ unsigned long flags;
++
++ //printk (KERN_INFO"%s: bus: %p status: %d\n", __FUNCTION__, bus, bus->status);
++
++ RETURN_ZERO_IF (!endpoint);
++ udc_interrupts++;
++
++ TRACE_MSG32 ("BI START ENDPOINT IN: tx_urb: %x", (int)endpoint->tx_urb);
++ local_irq_save (flags);
++ // call udc_start_endpoint_in IFF we didn't previously have a tx urb
++ if (!endpoint->tx_urb && bi_tx_next_irq (endpoint)) {
++ TRACE_MSG16 ("BI START ENDPOINT IN: bEndpointAddress: %x actual_length: %d",
++ (int)endpoint->bEndpointAddress, endpoint->tx_urb->actual_length);
++ udc_ops.start_endpoint_in (endpoint);
++ }
++ local_irq_restore (flags);
++ //printk (KERN_INFO"%s: finis\n", __FUNCTION__);
++ return 0;
++}
++
++/* bi_start_endpoint_out
++ */
++int bi_start_endpoint_out (struct usb_bus_instance *bus, struct usb_endpoint_instance *endpoint)
++{
++ unsigned long flags;
++
++ //printk (KERN_INFO"%s: bus: %p status: %d\n", __FUNCTION__, bus, bus->status);
++
++ RETURN_ZERO_IF (!endpoint);
++ udc_interrupts++;
++ TRACE_MSG32 ("BI START ENDPOINT OUT: rcv_urb: %x", (int)endpoint->rcv_urb);
++ local_irq_save (flags);
++ // call udc_start_endpoint_OUT IFF we didn't previously have a rcv urb
++ if (!endpoint->rcv_urb && bi_rcv_next_irq (endpoint)) {
++ TRACE_MSG16 ("BI START ENDPOINT OUT: bEndpointAddress: %x request_length: %d",
++ (int)endpoint->bEndpointAddress, endpoint->rcv_urb->request_length);
++ udc_ops.start_endpoint_out (endpoint);
++ }
++ local_irq_restore (flags);
++ //printk (KERN_INFO"%s: finis\n", __FUNCTION__);
++ return 0;
++}
++
++
++/* bi_cancel_urb_irq - cancel sending an urb
++ * Used by the USB Device Core to cancel an urb.
++ */
++int bi_cancel_urb_irq (struct urb *urb)
++{
++ RETURN_EINVAL_IF (!urb);
++ switch (urb->endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
++ case USB_DIR_IN:
++ //printk (KERN_INFO"%s: IN urb: %p\n", __FUNCTION__, urb);
++ // is this the active urb?
++ if (urb->endpoint->tx_urb == urb) {
++ urb->endpoint->tx_urb = NULL;
++ if (udc_ops.cancel_in_irq) udc_ops.cancel_in_irq (urb);
++ }
++ usbd_urb_sent_finished_irq (urb, SEND_FINISHED_CANCELLED);
++ break;
++
++ case USB_DIR_OUT:
++ //printk (KERN_INFO"%s: OUT urb: %p\n", __FUNCTION__, urb);
++ // is this the active urb?
++ if (urb->endpoint->rcv_urb == urb) {
++ urb->endpoint->rcv_urb = NULL;
++ if (udc_ops.cancel_out_irq) udc_ops.cancel_out_irq (urb);
++ }
++ TRACE_MSG ("CANCEL RECV URB");
++ usbd_urb_recv_finished_irq (urb, RECV_CANCELLED);
++ break;
++ }
++ return 0;
++}
++
++struct urb * bi_rcv_complete_irq (struct usb_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ struct urb *rcv_urb;
++
++ // if we had an urb then update actual_length, dispatch if neccessary
++ if (likely ( (int) (rcv_urb = endpoint->rcv_urb))) {
++
++ //printk (KERN_ERR"%s: actual: %d buffer: %d\n",
++ // __FUNCTION__, rcv_urb->actual_length, rcv_urb->buffer_length);
++
++ TRACE_MSG8 ("BI RCV COMPLETE: actual: %d len: %d bad: %d: status: %d",
++ rcv_urb->actual_length, len, urb_bad, rcv_urb->status);
++
++ TRACE_MSG8 ("BI RCV COMPLETE: request: %d buffer: %d packet: %d transfer: %d",
++ rcv_urb->request_length, rcv_urb->buffer_length,
++ endpoint->wMaxPacketSize, endpoint->rcv_transferSize);
++
++ // check the urb is ok, are we adding data less than the packetsize
++ if (!urb_bad && !endpoint->rcv_error && (rcv_urb->bus->status == USBD_OK) && (len <= endpoint->wMaxPacketSize)) {
++
++ // increment the received data size
++ rcv_urb->actual_length += len;
++
++ // if the current received data is short (less than full packetsize) which
++ // indicates the end of the bulk transfer, we have received the maximum
++ // transfersize, or if we do not have enough room to receive another packet
++ // then pass this data up to the function driver
++
++ // XXX this needs to be fixed, for example the MSC driver
++ // has varying maximum sizes
++
++
++ if (
++ ( (len < endpoint->wMaxPacketSize) ||
++ (rcv_urb->actual_length >= endpoint->rcv_transferSize) ||
++ (rcv_urb->actual_length >= rcv_urb->request_length) ||
++ (rcv_urb->actual_length + endpoint->wMaxPacketSize > rcv_urb->buffer_length)))
++ {
++#if 0
++ int i;
++ for (i = 0; i < rcv_urb->actual_length; TRACE_RECV (rcv_urb->buffer + i), i+= 8);
++#endif
++ endpoint->rcv_urb = NULL;
++ rcv_urb->jiffies = jiffies;
++ rcv_urb->framenum = udc_ops.framenum ? udc_ops.framenum () : 0;
++ TRACE_MSG32 ("BI RCV COMPLETE: finished length: %d", rcv_urb->actual_length);
++ TRACE_MSG32 ("BI RCV COMPLETE: framenum: %x", (int) rcv_urb->framenum);
++ usbd_urb_recv_finished_irq (rcv_urb, RECV_OK);
++ rcv_urb = NULL;
++ }
++ }
++ else {
++ rcv_urb->actual_length = 0;
++ //endpoint->rcv_error = 1;
++ }
++ }
++
++ // if we don't have an urb see if we can get one
++ return bi_rcv_next_irq (endpoint);
++}
++
++struct urb * bi_tx_complete_irq (struct usb_endpoint_instance *endpoint, int restart)
++{
++ struct urb *tx_urb;
++
++ // if we have a tx_urb advance or reset, finish if complete
++ if ( (likely ( (int)tx_urb = endpoint->tx_urb))) {
++
++ TRACE_MSG32 ("BI TX CURRENT TX_URB: %p", (int)endpoint->tx_urb);
++ TRACE_MSG8 ("BI TX COMPLETE: actual: %d sent: %d last: %d: status: %d",
++ tx_urb->actual_length, endpoint->sent, endpoint->last, tx_urb->status);
++
++ if (likely (!restart)) {
++ int sent = endpoint->last;
++ endpoint->sent += sent;
++ endpoint->last -= sent;
++ }
++ else
++ endpoint->last = 0;
++
++ //printk (KERN_INFO"%s: act: %d last: %d sent: %d status: %d flags: %x\n", __FUNCTION__,
++ // endpoint->tx_urb->actual_length, endpoint->last, endpoint->sent,
++ // tx_urb->status, tx_urb->flags);
++
++ // XXX is the test for bEndpointAddress still appropriate for CONTROL WRITES
++ if ( ( (tx_urb->actual_length - endpoint->sent) <= 0) && ! (tx_urb->flags & USBD_URB_SENDZLP) ) {
++ //if (endpoint->bEndpointAddress)
++ tx_urb->jiffies = jiffies;
++ tx_urb->framenum = udc_ops.framenum ? udc_ops.framenum () : 0;
++ TRACE_MSG32 ("BI TX COMPLETE: finished tx_urb: %p", (int)tx_urb);
++ TRACE_MSG32 ("BI TX COMPLETE: framenum: %x", (int)tx_urb->framenum);
++ usbd_urb_sent_finished_irq (tx_urb, SEND_FINISHED_OK);
++ endpoint->tx_urb = NULL;
++ endpoint->last = endpoint->sent = 0;
++ }
++ }
++ return bi_tx_next_irq (endpoint);
++}
++
++/* ******************************************************************************************* */
++/* bi_udc_init_irq - initialize USB Device Controller
++ * Get ready to use the USB Device Controller.
++ * Register the interrupt handlers and optional IO region.
++ * Return non-zero for error.
++ */
++int bi_udc_init_irq (void)
++{
++ THROW_IF (udc_ops.request_udc_irq ? udc_ops.request_udc_irq () : 0, irq_err);
++ THROW_IF (udc_ops.request_io ? udc_ops.request_io () : 0, io_err);
++ THROW_IF (udc_ops.init ? udc_ops.init () : 0, init_err);
++ CATCH (irq_err) {
++ printk (KERN_ERR"%s: could not request USB IRQ\n", __FUNCTION__);
++ CATCH (io_err) {
++ CATCH (init_err) {
++ printk (KERN_ERR"%s: could not request USB IO space\n", __FUNCTION__);
++ if (udc_ops.release_io) udc_ops.release_io ();
++ }
++ if (udc_ops.release_udc_irq) udc_ops.release_udc_irq ();
++ }
++ printk (KERN_ERR"%s: error\n", __FUNCTION__);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++
++/* bi_udc_exit - Stop using the USB Device Controller
++ * Stop using the USB Device Controller.
++ * Shutdown and free dma channels, de-register the interrupt handler.
++ */
++void bi_udc_exit (struct usb_bus_instance *bus)
++{
++ if (udc_ops.disable_ep) udc_ops.disable_ep (0);
++ bi_disable_endpoints (bus);
++ bi_disconnect (usbd_bus, NULL);
++ if (udc_ops.disable) udc_ops.disable ();
++ if (udc_ops.release_io) udc_ops.release_io ();
++ if (udc_ops.release_udc_irq) udc_ops.release_udc_irq ();
++}
++
++
++/* ************************************************************************************* */
++
++int bus_disable (struct usb_bus_instance *bus, char *arg);
++int bus_enable (struct usb_bus_instance *bus, char *arg);
++
++int bi_pm_off (struct usb_bus_instance *bus, char *arg)
++{
++ //printk (KERN_INFO"%s:\n", __FUNCTION__);
++ RETURN_EINVAL_IF (in_interrupt ());
++ return bus_disable (bus, arg);
++}
++
++int bi_pm_on (struct usb_bus_instance *bus, char *arg)
++{
++ //printk (KERN_INFO"%s:\n", __FUNCTION__);
++ RETURN_EINVAL_IF (in_interrupt ());
++ return bi_attached (usbd_bus) ? bus_enable (bus, arg) : 0;
++}
++
++int bi_fix_serial_number_str (struct usb_bus_instance *bus)
++{
++ char *sp, *dp;
++ for (sp = dp = usbd_bus->serial_number_str; sp && sp[0]; sp++) {
++ CONTINUE_IF (!isxdigit (sp[0]));
++ *dp++ = toupper (*sp);
++ }
++ if (dp)
++ *dp = '\0';
++ return 0;
++}
++
++int bi_serial_number (struct usb_bus_instance *bus, char *arg)
++{
++ char *sp, *dp;
++ RETURN_EINVAL_IF (in_interrupt ());
++ if (usbd_bus->serial_number_str)
++ lkfree (usbd_bus->serial_number_str);
++ usbd_bus->serial_number_str = lstrdup (arg);
++ bi_fix_serial_number_str (bus);
++ return 0;
++}
++
++
++/* ******************************************************************************************* */
++
++struct usb_bus_operations bi_ops = {
++ bus_enable: bus_enable,
++ bus_disable: bus_disable,
++ bus_pm_off: bi_pm_off,
++ bus_pm_on: bi_pm_on,
++ bus_serial_number: bi_serial_number,
++ start_endpoint_in: bi_start_endpoint_in,
++ start_endpoint_out: bi_start_endpoint_out,
++ cancel_urb_irq: bi_cancel_urb_irq,
++ endpoint_halted: bi_endpoint_halted,
++ device_feature: bi_device_feature,
++ device_event: bi_device_event_irq,
++ bus_disconnect: bi_disconnect,
++ bus_connect: bi_connect,
++ bus_attached: bi_attached,
++ bus_connected: bi_connected,
++ request_endpoints: bi_request_endpoints,
++ set_endpoints: bi_set_endpoints,
++};
++
++
++struct usb_bus_driver bi_driver = {
++ bops: &bi_ops,
++};
++
++void bi_cable_event_irq (void)
++{
++ (bi_attached (usbd_bus) ? usbd_enable_irq : usbd_disable_irq) (NULL);
++}
++
++void bi_cable_event (void)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ bi_cable_event_irq ();
++ local_irq_restore (flags);
++}
++
++
++/* Prevent overlapp of bi administrative functions mainly:
++ * bus_enable
++ * bus_disable
++ * bi_modinit
++ * bi_modexit
++ */
++DECLARE_MUTEX (usbd_bi_sem);
++
++int bus_disable_sem (struct usb_bus_instance *bus, char *arg)
++{
++ struct bi_data *data;
++ unsigned long flags;
++
++ RETURN_ZERO_IF (usbd_bus_state_enabled != bus->bus_state);
++ MOD_DEC_USE_COUNT;
++
++ bi_disconnect (usbd_bus, NULL);
++ if (udc_ops.disable) udc_ops.disable ();
++
++ local_irq_save (flags);
++ if (bus->device_state != STATE_ATTACHED) {
++ usbd_bus_event_irq (bus, DEVICE_RESET, 0);
++ usbd_bus_event_irq (bus, DEVICE_POWER_INTERRUPTION, 0);
++ usbd_bus_event_irq (bus, DEVICE_HUB_RESET, 0);
++ }
++ usbd_bus_event_irq (bus, DEVICE_DESTROY, 0);
++ bi_disable_endpoints (bus);
++ bi_udc_exit (bus);
++ local_irq_restore (flags);
++
++ usbd_disable_function (bus);
++ bus->bus_state = usbd_bus_state_disabled;
++ return 0;
++}
++
++int bus_disable (struct usb_bus_instance *bus, char *arg)
++{
++ RETURN_EINVAL_IF (in_interrupt ());
++ down (&usbd_bi_sem);
++ bus_disable_sem (bus, arg);
++ up (&usbd_bi_sem);
++ return 0;
++}
++
++void bi_startup_events(void)
++{
++ if (udc_ops.startup_events)
++ udc_ops.startup_events();
++ else {
++ usbd_bus_event_irq (usbd_bus, DEVICE_INIT, 0);
++ usbd_bus_event_irq (usbd_bus, DEVICE_CREATE, 0);
++ usbd_bus_event_irq (usbd_bus, DEVICE_HUB_CONFIGURED, 0);
++ usbd_bus_event_irq (usbd_bus, DEVICE_RESET, 0);
++ }
++}
++
++int bus_enable (struct usb_bus_instance *bus, char *arg)
++{
++ struct usb_endpoint_instance *endpoint;
++ int rc = -EINVAL;
++ unsigned long flags;
++
++ //printk (KERN_INFO "%s: %s bus_state: %d\n", __FUNCTION__, arg ? arg : " (NULL)", bus->bus_state);
++ RETURN_EINVAL_IF (in_interrupt ());
++
++ down (&usbd_bi_sem);
++ bus_disable_sem (bus, arg);
++ MOD_INC_USE_COUNT;
++
++ local_irq_save (flags);
++ do {
++ // check if we can see the UDC and register, then enable the function
++ BREAK_IF (bi_udc_init_irq ());
++ BREAK_IF (usbd_enable_function_irq (bus, arg));
++ rc = 0;
++
++ // setup endpoint zero
++ endpoint = bus->endpoint_array + 0;
++ endpoint->bEndpointAddress = 0;
++
++ //endpoint->tx_attributes = 0;
++ endpoint->wMaxPacketSize = udc_ops.ep0_packetsize;
++ endpoint->rcv_transferSize = 255; // XXX should this be higher
++ endpoint->wMaxPacketSize = udc_ops.ep0_packetsize;
++ if (udc_ops.setup_ep) udc_ops.setup_ep (0, endpoint);
++
++ // hopefully device enumeration will finish this process
++ bi_startup_events ();
++ trace_reinit ();
++ } while (0);
++ local_irq_restore (flags);
++ up (&usbd_bi_sem);
++
++ //printk (KERN_INFO"%s: finis\n", __FUNCTION__);
++ if (rc) {
++ printk (KERN_INFO "%s: failed\n", __FUNCTION__);
++ bi_udc_exit (NULL);
++ }
++ return rc;
++}
++
++/* ************************************************************************************* */
++
++static int bi_modinit (void)
++{
++ extern const char *usbd_bi_module_info (void);
++ //struct bi_data *data = NULL;
++ static int first = 0;
++
++ printk (KERN_INFO "%s: %s serial: \"%s\"\n", __FUNCTION__, usbd_bi_module_info (),
++ serial_number_str && strlen (serial_number_str) ? serial_number_str : "");
++
++ down (&usbd_bi_sem);
++
++ THROW_IF (trace_init (), error);
++ THROW_IF (usbd_bus, error);
++
++ // Set the UDC defaults
++ udc_ops.disable_interrupts ();
++ bi_disconnect (usbd_bus, NULL);
++
++ bi_driver.name = udc_ops.name;
++ bi_driver.max_endpoints = udc_ops.max_endpoints;
++ bi_driver.maxpacketsize = udc_ops.ep0_packetsize;
++
++ // register this bus interface driver and create the device driver instance
++ THROW_IF (! (usbd_bus = usbd_register_bus (&bi_driver)), error);
++
++ //THROW_IF (! (data = ckmalloc (sizeof (struct bi_data), GFP_KERNEL)), error);
++ //memset (data, 0, sizeof (struct bi_data));
++ //usbd_bus->privdata = data;
++
++ // see if we can scrounge up something to set a sort of unique device address
++ if (udc_ops.serial_init ? udc_ops.serial_init () : -EINVAL) {
++ if (serial_number_str && strlen (serial_number_str))
++ bi_serial_number (usbd_bus, serial_number_str);
++ }
++ else
++ bi_fix_serial_number_str (usbd_bus);
++
++ have_cable_irq = udc_ops.request_cable_irq ? !udc_ops.request_cable_irq () : 0;
++ up (&usbd_bi_sem);
++
++#if defined (MODULE) || !defined (CONFIG_USBD_BI_DELAY_ENABLE)
++ // if we are connected OR if we don't have a cable irq fake an attach event
++
++ // XXX this is not quite correct, if not attached then an enable
++ // will be required later if attached on a system that does not have
++ // cable event.
++ //
++ //if (!have_cable_irq || udc_attached ()) {
++ // Even if we have a cable irq, we need to check the current status,
++ // because the cable may have been attached before we installed the handler.
++
++ if (bi_attached (usbd_bus)) {
++ printk (KERN_INFO"%s: cable attached\n", __FUNCTION__);
++ bi_cable_event ();
++ }
++#endif
++ return 0;
++
++ CATCH (error) {
++ printk (KERN_ERR"%s: error loading module\n", __FUNCTION__);
++ //if (data)
++ // lkfree (data);
++ if (usbd_bus)
++ usbd_deregister_bus (usbd_bus);
++ usbd_bus = NULL;
++ trace_exit ();
++ up (&usbd_bi_sem);
++ printk (KERN_INFO"%s: UP\n", __FUNCTION__);
++ return -EINVAL;
++ }
++}
++
++#ifdef MODULE
++/* bi_modexit - This is *only* used for drivers compiled and used as a module.
++ */
++static void bi_modexit (void)
++{
++ down (&usbd_bi_sem);
++ RETURN_IF (!usbd_bus);
++
++ if (have_cable_irq)
++ udc_ops.release_cable_irq ();
++
++ bus_disable_sem (usbd_bus, NULL);
++
++ //if ( (usbd_bus->privdata))
++ // lkfree (usbd_bus->privdata);
++ //usbd_bus->privdata = NULL;
++
++ if (usbd_bus->serial_number_str)
++ lkfree (usbd_bus->serial_number_str);
++
++ usbd_deregister_bus (usbd_bus);
++ usbd_bus = NULL;
++ trace_exit ();
++}
++
++module_exit (bi_modexit);
++#endif
++
++module_init (bi_modinit);
++
+diff -Nru a/drivers/usbd/usbd-bi.h b/drivers/usbd/usbd-bi.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-bi.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,196 @@
++/*
++ * usbd/usbd-bi.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
++ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ * See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along with this program; if
++ * not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++struct udc_ops {
++
++ /* mandatory */
++ int max_endpoints;
++ int ep0_packetsize;
++ char *name;
++
++ void (*start_endpoint_in)
++ (struct usb_endpoint_instance *); /* start an IN urb */
++ void (*start_endpoint_out)
++ (struct usb_endpoint_instance *); /* start an OUT urb */
++
++ int (*request_endpoints)
++ (struct usb_endpoint_map *, int, struct usb_endpoint_request *);
++
++ /* optional */
++
++ int (*set_endpoints)
++ (int , struct usb_endpoint_map *);
++
++ void (*cancel_in_irq) (struct urb *urb); /* cancel active urb for IN endpoint */
++ void (*cancel_out_irq) (struct urb *urb); /* cancel active urb for OUT endpoint */
++
++ void (*reset_ep) (unsigned int ep); /* reset requested endpoint */
++ int (*endpoint_halted) (unsigned int ep); /* Return non-zero if requested endpoint is halted */
++
++ void (*set_address) (unsigned char address);/* set the device USB address */
++ int (* serial_init) (void); /* get device serial number if available */
++ void (*setup_ep) (unsigned int ep,
++ struct usb_endpoint_instance *endpoint); /* setup specified endpoint for use */
++ void (*disable_ep) (unsigned int ep); /* disable specified endpoint */
++ void (*stall_ep) (u32 ); /* stall endpoint */
++
++ int (*attached) (void); /* return non-zero if the USB cable connected */
++ int (*connected) (void); /* return non-zero if the USB pullup resistor is enabled */
++ void (*connect) (void); /* enable USB pullup resistor to enable connection to host */
++ void (*disconnect) (void); /* disable pullup resistor to disconnect from host */
++
++ int (*framenum) (void); /* fetch SOF framenum */
++
++ void (*all_interrupts) (void); /* enable all interrupts for normal operation */
++ void (*suspended_interrupts) (void); /* enable interrupts for suspended operation */
++ void (*disable_interrupts) (void); /* disable all interrupts */
++
++ void (*enable) (void); /* enable the UDC */
++ void (*disable) (void); /* disable the UDC */
++
++ void (*startup_events) (void); /* perform UDC specific USB events */
++ int (*init) (void); /* initialize USB Device Controller */
++
++ int (*request_udc_irq) (void); /* return non-zero if request for UDC interrupt fails */
++ int (*request_cable_irq) (void); /* return non-zero if request for Cable interrupt fails */
++ int (*request_io) (void); /* return non-zero if request UDC IO region fails */
++ void (*release_udc_irq) (void); /* release USB Device Controller interrupt */
++ void (*release_cable_irq) (void); /* release Cable interrupt */
++ void (*release_io) (void); /* release UDC IO region */
++};
++
++extern struct udc_ops udc_ops;
++extern unsigned int udc_interrupts;
++extern struct usb_bus_instance *usbd_bus;
++
++void bi_cable_event_irq (void); /* called from cradle interrupt handler */
++void bi_cable_event (void);
++
++/* bi_rcv_next_irq - complete a receive
++ * Called from rcv interrupt to complete.
++ */
++static __inline__ struct urb * bi_rcv_next_irq (struct usb_endpoint_instance *endpoint)
++{
++ if (!endpoint->rcv_urb)
++ if ( (endpoint->rcv_urb = usbd_first_urb_detached_irq (&endpoint->rdy)))
++ endpoint->rcv_urb->status = RECV_IN_PROGRESS;
++ TRACE_MSG32 ("BI RCV_URB: %p", (int)endpoint->rcv_urb);
++ return endpoint->rcv_urb;
++}
++
++
++/* bi_rcv_complete_irq - complete a receive
++ * Called from rcv interrupt to complete.
++ */
++struct urb * bi_rcv_complete_irq (struct usb_endpoint_instance *endpoint, int len, int urb_bad);
++
++static __inline__ void bi_rcv_cancelled_irq (struct usb_endpoint_instance *endpoint)
++{
++ struct urb *rcv_urb;
++
++ TRACE_MSG32 ("BI RCV CANCELLED: %p", (int) endpoint->rcv_urb);
++ RETURN_IF (! (rcv_urb = endpoint->rcv_urb));
++ printk (KERN_INFO"%s: rcv_urb: %p\n", __FUNCTION__, endpoint->rcv_urb);
++ usbd_urb_recv_finished_irq (rcv_urb, RECV_CANCELLED);
++ endpoint->sent = endpoint->last = 0;
++ endpoint->rcv_urb = NULL;
++ printk (KERN_INFO"%s: rcv_urb: %p\n", __FUNCTION__, endpoint->rcv_urb);
++}
++
++
++/* bi_tx_next_irq - complete a receive
++ * Called from tx interrupt to complete.
++ */
++static __inline__ struct urb * bi_tx_next_irq (struct usb_endpoint_instance *endpoint)
++{
++ if (!endpoint->tx_urb)
++ if ( (endpoint->tx_urb = usbd_first_urb_detached_irq (&endpoint->tx))) {
++#if 0
++ int i;
++ TRACE_MSG16 ("NEXT TX: length: %d flags: %x", endpoint->tx_urb->actual_length, endpoint->tx_urb->flags);
++ for (i = 0; i < endpoint->tx_urb->actual_length; TRACE_SENT (endpoint->tx_urb->buffer + i), i+= 8);
++#endif
++ endpoint->tx_urb->status = SEND_IN_PROGRESS;
++ }
++ TRACE_MSG32 ("BI TX NEXT TX_URB: %p", (int)endpoint->tx_urb);
++ return endpoint->tx_urb;
++}
++
++
++/* bi_tx_complete_irq - complete a transmit
++ * Called from tx interrupt to complete.
++ */
++struct urb * bi_tx_complete_irq (struct usb_endpoint_instance *endpoint, int restart);
++
++static __inline__ void bi_tx_cancelled_irq (struct usb_endpoint_instance *endpoint)
++{
++ struct urb *tx_urb;
++
++ TRACE_MSG32 ("BI TX CANCELLED: %p", (int) endpoint->tx_urb);
++ RETURN_IF (! (tx_urb = endpoint->tx_urb));
++ usbd_urb_sent_finished_irq (tx_urb, SEND_FINISHED_CANCELLED);
++ endpoint->sent = endpoint->last = 0;
++ endpoint->tx_urb = NULL;
++}
++
++static __inline__ int bi_tx_sendzlp (struct usb_endpoint_instance *endpoint)
++{
++ struct urb *tx_urb = endpoint->tx_urb;
++ RETURN_ZERO_IF (!tx_urb || (tx_urb->actual_length != endpoint->sent) || ! (tx_urb->flags & USBD_URB_SENDZLP));
++ tx_urb->flags &= ~USBD_URB_SENDZLP;
++ return 1;
++}
++
++/* bi_rcv_complete_irq - complete a receive
++ * Called from rcv interrupt to complete.
++ */
++static __inline__ void bi_rcv_fast_complete_irq (struct usb_endpoint_instance *endpoint, struct urb *rcv_urb)
++{
++ TRACE_MSG32 ("BI RCV FAST COMPLETE: %d", rcv_urb->actual_length);
++ usbd_urb_recv_finished_irq (rcv_urb, RECV_OK);
++}
++
++/* bi_recv_setup - process a device request
++ * Note that we verify if a receive urb has been queued for H2D with non-zero wLength
++ * and return -EINVAL to stall if the upper layers have not properly tested for and
++ * setup a receive urb in this case.
++ */
++static __inline__ int bi_recv_setup_irq (struct usb_device_request *request)
++{
++ struct usb_endpoint_instance *endpoint = usbd_bus->endpoint_array + 0;
++ TRACE_SETUP (request);
++ RETURN_EINVAL_IF (usbd_recv_setup_irq (usbd_bus->ep0, request)); // fail if already failed
++ RETURN_ZERO_IF ( (request->bmRequestType & USB_REQ_DIRECTION_MASK) == USB_REQ_DEVICE2HOST);
++ RETURN_ZERO_IF (!le16_to_cpu (request->wLength));
++ RETURN_EINVAL_IF (!endpoint->rcv_urb);
++ return 0;
++}
++
++/* bi_ep0_reset_irq - reset ep0 endpoint
++ */
++static void __inline__ bi_ep0_reset_endpoint_irq (struct usb_endpoint_instance *endpoint)
++{
++ bi_tx_cancelled_irq (endpoint);
++ bi_rcv_cancelled_irq (endpoint);
++ endpoint->sent = endpoint->last = 0;
++}
+diff -Nru a/drivers/usbd/usbd-bops.c b/drivers/usbd/usbd-bops.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-bops.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,889 @@
++/*
++ * usbd/usbd-bops.c - USB Device Prototype
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/list.h>
++#include <asm/uaccess.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/smp_lock.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/string.h>
++
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-func.h"
++#include "usbd-bus.h"
++
++/* Private defs from usbd-func.c *************************************************************** */
++/* Function driver enable/disable
++ *
++ * Called by usbd_enable_function/usbd_disable_function to call the selected
++ * function drivers function_enable or function_disable function.
++ */
++int usbd_function_enable (struct usb_bus_instance *, struct usb_function_instance *);
++void usbd_function_disable(struct usb_function_instance *);
++void usbd_func_event_irq(struct usb_bus_instance *, struct usb_function_instance *, usb_device_event_t , int );
++int usbd_strings_init (void);
++void usbd_strings_exit(void);
++void usbd_urb_callback (struct urb *urb, int rc);
++
++/* List support functions ******************************************************************** */
++
++/*
++ * Structure member address manipulation macros.
++ * These are used by client code (code using the urb_link routines), since
++ * the urb_link structure is embedded in the client data structures.
++ *
++ * Note: a macro offsetof equivalent to member_offset is defined in stddef.h
++ * but this is kept here for the sake of portability.
++ *
++ * p2surround returns a pointer to the surrounding structure given
++ * type of the surrounding structure, the name memb of the structure
++ * member pointed at by ptr. For example, if you have:
++ *
++ * struct foo {
++ * int x;
++ * float y;
++ * char z;
++ * } thingy;
++ *
++ * char *cp = &thingy.z;
++ *
++ * then
++ * &thingy == p2surround(struct foo, z, cp)
++ */
++
++#define _cv_(ptr) ((char*)(void*)(ptr))
++#define member_offset(type,memb) (_cv_(&(((type*)0)->memb))-(char*)0)
++#define p2surround(type,memb,ptr) ((type*)(void*)(_cv_(ptr)-member_offset(type,memb)))
++
++static inline struct usb_function_driver *list_entry_function (const struct list_head *le)
++{
++ return list_entry (le, struct usb_function_driver, drivers);
++}
++
++
++/*
++ * Append an urb_link (or a whole list of
++ * urb_links) to the tail of another list
++ * of urb_links.
++ */
++static __inline__ void urb_append_irq (urb_link * hd, struct urb *urb)
++{
++ if (hd && urb) {
++ urb_link *new = &urb->link;
++
++#ifdef C2L_SINGLETON_ONLY
++ // This _assumes_ the new urb is a singleton,
++ // but allows it to have an uninitialized link.
++ //printk(KERN_DEBUG"urb_append: hd: %p n:%p p:%p new: %p n:%p p:%p\n", hd, hd->next, hd->prev, new, new->next, new->prev);
++
++ new->prev = hd->prev;
++ new->next = hd;
++
++ hd->prev->next = new;
++ hd->prev = new;
++#else
++ // This allows the new urb to be a list of urbs,
++ // with new pointing at the first, but the link
++ // must be initialized.
++ // Order is important here...
++ urb_link *pul = hd->prev;
++ new->prev->next = hd;
++ hd->prev = new->prev;
++ new->prev = pul;
++ pul->next = new;
++#endif
++ }
++}
++
++/*
++ * Return the first urb_link in a list with a distinguished
++ * head "hd", or NULL if the list is empty. This will also
++ * work as a predicate, returning NULL if empty, and non-NULL
++ * otherwise.
++ *
++ * Called from interrupt.
++ */
++static __inline__ urb_link *first_urb_link_irq (urb_link * hd)
++{
++ urb_link *nx;
++ return (!hd || !(nx = hd->next) || (nx == hd)) ? NULL : nx;
++}
++
++/*
++ * Return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ *
++ * Called from interrupt.
++ */
++static __inline__ struct urb *first_urb_irq (urb_link * hd)
++{
++ urb_link *nx;
++ return (!(nx = first_urb_link_irq (hd))) ? NULL : p2surround (struct urb, link, nx);
++}
++
++/*
++ * Detach and return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ */
++struct urb *usbd_first_urb_detached_irq (urb_link * hd)
++{
++ struct urb *urb;
++ urb_link *ul;
++ RETURN_NULL_IF (!(urb = first_urb_irq (hd)));
++ ul = &urb->link;
++ ul->next->prev = ul->prev;
++ ul->prev->next = ul->next;
++ ul->prev = ul->next = ul;
++ return urb;
++}
++
++static __inline__ void urb_append(urb_link *hd, struct urb *urb)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ urb_append_irq(hd, urb);
++ local_irq_restore (flags);
++}
++
++/* usbd_urb_sent_finished_irq - tell function that an urb has been transmitted.
++ *
++ * Must be called from an interrupt or with interrupts disabled.
++ *
++ * Used by a USB Bus driver to pass a sent urb back to the function
++ * driver via the endpoints done queue.
++ */
++void usbd_urb_sent_finished_irq (struct urb *urb, int rc)
++{
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++ urb->status = rc;
++ urb->jiffies = jiffies;
++ if (USBD_OK != urb->bus->status)
++ usbd_urb_callback(urb, urb->status);
++ else {
++ urb_append_irq (&(urb->endpoint->done), urb);
++ RETURN_IF ( urb->bus->device_bh.sync);
++ queue_task (&urb->bus->device_bh, &tq_immediate);
++ mark_bh (IMMEDIATE_BH);
++ }
++}
++
++
++/* usbd_urb_recv_finished_irq - tell function that an urb has been received.
++ *
++ * Must be called from an interrupt or with interrupts disabled.
++ *
++ * Used by a USB Bus driver to pass a sent urb back to the function
++ * driver via the endpoints done queue.
++ */
++void usbd_urb_recv_finished_irq (struct urb *urb, int rc)
++{
++ urb->status = rc;
++ urb->jiffies = jiffies;
++ if (USBD_OK != urb->bus->status)
++ usbd_urb_callback (urb, rc);
++ else {
++ urb_append_irq (&(urb->endpoint->rcv), urb);
++ RETURN_IF (urb->bus->device_bh.sync);
++ queue_task (&urb->bus->device_bh, &tq_immediate);
++ mark_bh (IMMEDIATE_BH);
++ }
++}
++
++
++/* first_urb_detached -
++ *
++ * Detach and return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ *
++ */
++static __inline__ struct urb *first_urb_detached (urb_link * hd)
++{
++ struct urb *urb;
++ unsigned long flags;
++ local_irq_save (flags);
++ urb = usbd_first_urb_detached_irq (hd);
++ local_irq_restore (flags);
++ return urb;
++}
++
++
++/* Private defs from usbd-fops.c *************************************************************** */
++
++
++extern struct usb_function_driver ep0_driver;
++extern struct list_head usbd_function_drivers;
++extern struct usb_bus_instance *usbd_bus_instance;
++
++#define LANGID_ENGLISH "\011"
++#define LANGID_US_ENGLISH "\004"
++#define LANGIDs LANGID_US_ENGLISH LANGID_ENGLISH
++
++/* usbd_flush_endpoint_irq - flush urbs from endpoint
++ *
++ * Iterate across the approrpiate tx or rcv list and cancel any outstanding urbs.
++ */
++void usbd_flush_endpoint_irq (struct usb_endpoint_instance *endpoint)
++{
++ struct urb *urb;
++ //printk(KERN_INFO"%s: bEndpointAddress: %d\n", __FUNCTION__, endpoint->bEndpointAddress);
++ if ((urb = endpoint->tx_urb))
++ usbd_cancel_urb_irq(urb);
++
++ for (; (urb = usbd_first_urb_detached_irq (&endpoint->tx)); usbd_cancel_urb_irq(urb));
++
++ if ((urb = endpoint->rcv_urb))
++ usbd_cancel_urb_irq(urb);
++
++ for (; (urb = usbd_first_urb_detached_irq (&endpoint->rdy)); usbd_cancel_urb_irq(urb));
++}
++
++/* usbd_flush_endpoint - flush urbs from endpoint
++ *
++ * Iterate across the approrpiate tx or rcv list and cancel any outstanding urbs.
++ */
++void usbd_flush_endpoint (struct usb_endpoint_instance *endpoint)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ usbd_flush_endpoint_irq(endpoint);
++ local_irq_restore (flags);
++}
++
++/* usbd_endpoint_halted
++ *
++ * Return non-zero if endpoint is halted.
++ */
++int usbd_endpoint_halted (struct usb_function_instance *function, int endpoint)
++{
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ return function->bus->driver->bops->endpoint_halted (function->bus, endpoint);
++}
++
++
++/* usbd_device_feature - set usb device feature
++ *
++ * Return non-zero if error
++ */
++int usbd_device_feature (struct usb_function_instance *function, int endpoint, int feature)
++{
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ return function->bus->driver->bops->device_feature (function->bus, endpoint, feature);
++}
++
++/* usbd_cancel_urb_irq - cancel an urb being sent
++ *
++ * Return non-zero if error
++ */
++int usbd_cancel_urb_irq (struct urb *urb)
++{
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++ // XXX should we do usbd_dealloc_urb(urb);
++ return urb->bus->driver->bops->cancel_urb_irq (urb);
++}
++
++/* usbd_send_urb - submit a urb to send
++ *
++ * Used by a USB Function driver to submit data to be sent in an urb to the
++ * appropriate USB Bus driver via the endpoints transmit queue.
++ *
++ * Return non-zero if error
++ */
++int usbd_send_urb (struct urb *urb)
++{
++ //printk(KERN_INFO"%s: urb: %p length: %d\n", __FUNCTION__, urb, urb->actual_length);
++ //RETURN_EINVAL_IF (USBD_OK != urb->bus->status);
++ RETURN_EINVAL_IF (urb->endpoint->bEndpointAddress && (USBD_OK != urb->bus->status));
++ urb->status = SEND_IN_QUEUE;
++ urb->jiffies = jiffies;
++ urb_append (&(urb->endpoint->tx), urb);
++ return urb->bus->driver->bops->start_endpoint_in(urb->bus, urb->endpoint);
++}
++
++/* usbd_start_recv - recycle a received urb
++ *
++ * Used by a USB Function interface driver to recycle an urb.
++ *
++ * Return non-zero if error
++ */
++int usbd_start_recv (struct urb *urb)
++{
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++ RETURN_EINVAL_IF (urb->endpoint->bEndpointAddress && (USBD_OK != urb->bus->status));
++ urb->actual_length = 0;
++ urb->status = RECV_IN_QUEUE;
++ urb->jiffies = jiffies;
++ urb_append (&(urb->endpoint->rdy), urb);
++ urb->bus->driver->bops->start_endpoint_out(urb->bus, urb->endpoint);
++ //printk(KERN_INFO"%s: finis\n", __FUNCTION__, urb);
++ return 0;
++}
++
++/* usbd_alloc_string_zero - allocate a string descriptor and return index number
++ *
++ * Find an empty slot in index string array, create a corresponding descriptor
++ * and return the slot number.
++ */
++__u8 usbd_alloc_string_zero (char *str)
++{
++ __u8 bLength;
++ __u16 *wData;
++ struct usb_string_descriptor *string;
++
++ RETURN_ZERO_IF(usb_strings[0] != NULL);
++
++ bLength = sizeof (struct usb_string_descriptor) + strlen (str);
++
++ RETURN_ZERO_IF(!(string = ckmalloc (bLength, GFP_KERNEL)));
++
++ string->bLength = bLength;
++ string->bDescriptorType = USB_DT_STRING;
++
++ for (wData = string->wData; *str; str += 2) {
++ *wData = (__u16) ((str[0] << 8 | str[1]));
++ wData++;
++ }
++ usb_strings[0] = string; // store in string index array
++ return 0;
++}
++
++
++int usbd_strings_init (void)
++{
++ //printk(KERN_INFO"%s: usb_strings: %p\n", __FUNCTION__, usb_strings);
++ RETURN_ZERO_IF(usb_strings);
++ usbd_maxstrings = MIN(usbd_maxstrings, 254);
++
++ RETURN_EINVAL_IF (!(usb_strings = ckmalloc (sizeof (struct usb_string_descriptor *) * usbd_maxstrings, GFP_KERNEL)));
++ if (usbd_alloc_string_zero (LANGIDs) != 0) {
++ lkfree (usb_strings);
++ return -1;
++ }
++ return 0;
++}
++
++void usbd_strings_exit(void)
++{
++ int i;
++ //printk(KERN_INFO"%s: usb_strings: %p\n", __FUNCTION__, usb_strings);
++ RETURN_IF (!usb_strings);
++ for (i = 0; i < usbd_maxstrings; i++)
++ usbd_dealloc_string(i);
++ lkfree (usb_strings);
++ usb_strings = NULL;
++}
++
++static usb_device_state_t event_states[DEVICE_CLOSE] = {
++ STATE_UNKNOWN, STATE_INIT, STATE_ATTACHED, STATE_POWERED,
++ STATE_DEFAULT, STATE_ADDRESSED, STATE_CONFIGURED, STATE_UNKNOWN,
++ STATE_UNKNOWN, STATE_UNKNOWN, STATE_ADDRESSED, STATE_SUSPENDED,
++ STATE_UNKNOWN, STATE_POWERED, STATE_ATTACHED,
++};
++
++static usb_device_status_t event_status[DEVICE_CLOSE+1] = {
++ USBD_UNKNOWN, // DEVICE_UNKNOWN
++ USBD_OPENING, // DEVICE_INIT
++ USBD_OPENING, // DEVICE_CREATE
++ USBD_OPENING, // DEVICE_HUB_CONFIGURED
++ USBD_RESETING, // DEVICE_RESET
++ USBD_OK, // DEVICE_ADDRESS_ASSIGNED
++ USBD_OK, // DEVICE_CONFIGURED
++ USBD_OK, // DEVICE_SET_INTERFACE
++ USBD_OK, // DEVICE_SET_FEATURE
++ USBD_OK, // DEVICE_CLEAR_FEATURE
++ USBD_OK, // DEVICE_DE_CONFIGURED
++ USBD_SUSPENDED, // DEVICE_BUS_INACTIVE
++ USBD_OK, // DEVICE_BUS_ACTIVITY
++ USBD_RESETING, // DEVICE_POWER_INTERRUPTION
++ USBD_RESETING, // DEVICE_HUB_RESET
++ USBD_CLOSING, // DEVICE_DESTROY
++ USBD_CLOSED, // DEVICE_CLOSE
++};
++
++/* usbd_device_event_irq - called to respond to various usb events
++ *
++ * Used by a Bus driver to indicate an event.
++ */
++void usbd_bus_event_irq (struct usb_bus_instance *bus, usb_device_event_t event, int data)
++{
++ RETURN_IF(!bus);
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ //printk(KERN_INFO"%s: --> event: %d status: %d state: %d\n", __FUNCTION__, event, bus->status, bus->device_state);
++ switch (event) {
++ case DEVICE_BUS_INACTIVE:
++ bus->suspended_state = bus->device_state;
++ //printk(KERN_INFO"%s: INACTIVE\n", __FUNCTION__);
++ /* FALL THROUGH */
++ default:
++ bus->device_state = event_states[event];
++ //printk(KERN_INFO"%s: DEFAUL\n", __FUNCTION__);
++ break;
++ case DEVICE_UNKNOWN:
++ //printk(KERN_INFO"%s: UNKNOWN\n", __FUNCTION__);
++ break;
++ case DEVICE_BUS_ACTIVITY:
++ bus->device_state = bus->suspended_state;
++ //printk(KERN_INFO"%s: ACTIVITY\n", __FUNCTION__);
++ break;
++
++ case DEVICE_SET_INTERFACE:
++ case DEVICE_SET_FEATURE:
++ case DEVICE_CLEAR_FEATURE:
++ //printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ break;
++ }
++
++ switch (event) {
++ case DEVICE_BUS_ACTIVITY:
++ case DEVICE_BUS_INACTIVE:
++ BREAK_IF(USBD_CLOSING != bus->status);
++ /* FALL THROUGH */
++ default:
++ bus->status = event_status[event];
++ //printk(KERN_INFO"%s: DEFAULT\n", __FUNCTION__);
++ break;
++ }
++ //printk(KERN_INFO"%s: <-- event: %d status: %d state: %d\n", __FUNCTION__, event, bus->status, bus->device_state);
++
++ // if we lost configuration then get rid of alternate settings
++ if ((bus->device_state != STATE_CONFIGURED) && bus->bNumInterfaces && bus->alternates) {
++ bus->bNumInterfaces = 0;
++ lkfree(bus->alternates);
++ bus->alternates = NULL;
++ }
++ bus->driver->bops->device_event (bus, event, data);
++ usbd_func_event_irq (bus, bus->ep0, event, data);
++ usbd_func_event_irq (bus, bus->function_instance, event, data);
++}
++
++
++/* usbd_bus_event
++ */
++void usbd_bus_event (struct usb_bus_instance *bus, usb_device_event_t event, int data)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ usbd_bus_event_irq (bus, event, data);
++ local_irq_restore (flags);
++}
++
++
++/* usbd_attached - return cable status
++ *
++ * Return non-zero if cable attached
++ */
++int usbd_attached (struct usb_bus_instance *bus)
++{
++ return bus->driver->bops->bus_attached (bus);
++}
++
++/* usbd_connected - return pullup resistor control status
++ * *
++ * * Return non-zero if pullup enabled
++ * */
++int usbd_connected (struct usb_bus_instance *bus)
++{
++ return bus->driver->bops->bus_connected (bus);
++}
++
++
++/* usbb bus bottom half ********************************************************************** */
++
++/*
++ * Note that all of the functions from here to the end of the file protect against
++ * overlapped operation using the usbd_bus_sem
++ *
++ * usbd_device_bh
++ *
++ * usbd_register_bus
++ * usbd_deregister_bus
++ * usbd_enable_function_irq
++ * usbd_disable_function
++ */
++DECLARE_MUTEX(usbd_bus_sem);
++
++
++/* usbd_device_bh -
++ *
++ * Bottom half handler to process sent or received urbs.
++ */
++void usbd_device_bh (void *data)
++{
++ int i;
++ struct usb_bus_instance *bus = data;
++ struct usb_endpoint_instance *endpoint;
++
++ RETURN_IF (!bus || !(endpoint = bus->endpoint_array));
++ down(&usbd_bus_sem);
++ // process received and sent urbs
++ for (i = 0; i < bus->endpoints; i++, endpoint++) {
++ struct urb *urb;
++ for (; (urb = first_urb_detached (&endpoint->rcv )); usbd_urb_callback (urb, urb->status));
++ for (; (urb = first_urb_detached (&endpoint->done)); usbd_urb_callback (urb, urb->status));
++ }
++ if (USBD_CLOSING == bus->status)
++ bus->device_bh.data = NULL;
++ up(&usbd_bus_sem);
++}
++
++
++/* usb-device USB BUS INTERFACE generic functions ******************************************** */
++
++/*
++ * Initialize an urb_link to be a single element list.
++ * If the urb_link is being used as a distinguished list head
++ * the list is empty when the head is the only link in the list.
++ */
++static __inline__ void urb_link_init (urb_link * ul)
++{
++ ul->prev = ul->next = ul;
++}
++
++/* usbd_register_bus - called by a USB BUS INTERFACE driver to register a bus driver
++ *
++ * Used by a USB Bus interface driver to register itself with the usb device layer.
++ *
++ * Return non-zero if error
++ */
++struct usb_bus_instance *usbd_register_bus (struct usb_bus_driver *driver)
++{
++ int i;
++ struct usb_bus_instance *bus = NULL;
++
++ //printk(KERN_INFO"%s: DOWN USBD_BUS_SEM\n", __FUNCTION__);
++ down(&usbd_bus_sem);
++ MOD_INC_USE_COUNT; // QQQ should this be before the down()?
++
++ THROW_IF(usbd_bus_instance, error);
++ THROW_IF((bus = ckmalloc (sizeof (struct usb_bus_instance), GFP_ATOMIC)) == NULL, error);
++
++ bus->driver = driver;
++ bus->endpoints = bus->driver->max_endpoints;
++
++ THROW_IF(!(bus->endpoint_array = ckmalloc(sizeof (struct usb_endpoint_instance) * bus->endpoints, GFP_ATOMIC)), error);
++
++ for (i = 0; i < bus->endpoints; i++) {
++ struct usb_endpoint_instance *endpoint = bus->endpoint_array + i;
++ endpoint->physical_endpoint = i;
++ urb_link_init (&endpoint->rcv);
++ urb_link_init (&endpoint->rdy);
++ urb_link_init (&endpoint->tx);
++ urb_link_init (&endpoint->done);
++ }
++
++ bus->admin[usbd_admin_enable] = driver->bops->bus_enable;
++ bus->admin[usbd_admin_disable] = driver->bops->bus_disable;
++ bus->admin[usbd_admin_disconnect] = driver->bops->bus_disconnect;
++ bus->admin[usbd_admin_connect] = driver->bops->bus_connect;
++ bus->admin[usbd_admin_pm_off] = driver->bops->bus_pm_off;
++ bus->admin[usbd_admin_pm_on] = driver->bops->bus_pm_on;
++ bus->admin[usbd_admin_serial_number] = driver->bops->bus_serial_number;
++
++ THROW_IF((bus->ep0 = ckmalloc (sizeof (struct usb_function_instance), GFP_ATOMIC)) == NULL, error)
++ bus->ep0->function_driver = &ep0_driver;
++ bus->ep0->endpointsRequested = 1;
++ THROW_IF(!(bus->ep0->endpoint_map_array = ckmalloc(sizeof(struct usb_endpoint_map) * 1, GFP_KERNEL)), error);
++
++ bus->device_state = STATE_CREATED;
++ bus->status = USBD_OPENING;
++
++ usbd_bus_instance = bus;
++
++ CATCH(error) {
++ if (bus) {
++ if (bus->endpoint_array)
++ lkfree(bus->endpoint_array);
++ lkfree(bus);
++ }
++ bus->endpoints = 0;
++ printk(KERN_INFO"%s: FAILED\n", __FUNCTION__);
++ bus = NULL;
++ MOD_DEC_USE_COUNT;
++ }
++
++ up(&usbd_bus_sem);
++ //printk(KERN_INFO"%s: UP USBD_BUS_SEM\n", __FUNCTION__);
++ return bus;
++}
++
++/* usbd_deregister_bus - called by a USB BUS INTERFACE driver to deregister a bus driver
++ *
++ * Used by a USB Bus interface driver to de-register itself with the usb device
++ * layer.
++ */
++void usbd_deregister_bus (struct usb_bus_instance *bus)
++{
++ //printk(KERN_INFO"%s: DOWN USBD_BUS_SEM\n", __FUNCTION__);
++ down(&usbd_bus_sem);
++
++ usbd_bus_instance = NULL;
++
++ if (bus->ep0) {
++ if (bus->ep0->endpoint_map_array)
++ lkfree(bus->ep0->endpoint_map_array);
++ lkfree(bus->ep0);
++ }
++
++ lkfree (bus->arg);
++ lkfree (bus->endpoint_array);
++ lkfree (bus);
++ bus->endpoints = 0;
++ MOD_DEC_USE_COUNT; // QQQ should this be after the up()?
++ up(&usbd_bus_sem);
++ //printk(KERN_INFO"%s: UP USBD_BUS_SEM\n", __FUNCTION__);
++}
++
++
++/* usb-device USB Device generic functions *************************************************** */
++
++/* usbd_enable_function_irq - called to enable the desired function
++ *
++ * Used by a USB Bus interface driver to create a virtual device.
++ *
++ * Return non-zero if error
++ */
++int usbd_enable_function_irq (struct usb_bus_instance *bus, char *arg)
++{
++ struct usb_function_instance *function = NULL;
++ struct list_head *lhd;
++ int len = 0;
++ int i;
++ int rc = -EINVAL;
++ int epn;
++
++ //printk(KERN_INFO"%s: DOWN USBD_BUS_SEM\n", __FUNCTION__);
++ down(&usbd_bus_sem);
++
++ if (arg && bus->arg)
++ lkfree(bus->arg);
++
++ if (arg) {
++ bus->arg = lstrdup(arg);
++ len = strlen(arg);
++ }
++
++ // initialize the strings pool
++ THROW_IF(usbd_strings_init (), error);
++
++ for (i = 1; i < bus->endpoints; i++) {
++ struct usb_endpoint_instance *endpoint = bus->endpoint_array + i;
++ endpoint->rcv_urb = endpoint->tx_urb = NULL;
++ }
++
++ list_for_each (lhd, &usbd_function_drivers) {
++ struct usb_function_driver *function_driver;
++ function_driver = list_entry_function (lhd);
++
++ printk(KERN_INFO"%s: check: [%s] %s\n", __FUNCTION__,
++ (arg?arg:""), function_driver->name);
++
++ // mode - single, either the first or a named function
++ CONTINUE_IF(arg && len && strncmp(function_driver->name, arg, len));
++
++ //printk(KERN_INFO"%s: found: %s\n", __FUNCTION__, function_driver->name);
++
++ THROW_IF (!(function = ckmalloc (sizeof (struct usb_function_instance), GFP_ATOMIC)), error);
++ function->function_driver = function_driver; // XXX
++
++ THROW_IF (!(function->endpoint_map_array = ckmalloc (sizeof(struct usb_endpoint_map) *
++ function->function_driver->device_description->endpointsRequested,
++ GFP_KERNEL)), error);
++
++ THROW_IF(bus->driver->bops->request_endpoints( function->endpoint_map_array,
++ function->function_driver->device_description->endpointsRequested,
++ function->function_driver->device_description->requestedEndpoints), error);
++
++ function->endpointsRequested = function->function_driver->device_description->endpointsRequested;
++ usbd_function_enable (bus, function);
++ break;
++ }
++
++ if (NULL == function && NULL != arg && 0 != len) {
++ printk(KERN_INFO"Unknown function driver (len=%d) [%s], known drivers:\n",len,arg);
++ list_for_each (lhd, &usbd_function_drivers) {
++ struct usb_function_driver *function_driver = list_entry_function (lhd);
++ printk(KERN_INFO" [%s]\n", function_driver->name);
++ }
++ }
++
++ THROW_IF (!(bus->function_instance = function), error);
++
++ THROW_IF(bus->driver->bops->set_endpoints( function->function_driver->device_description->endpointsRequested,
++ function->endpoint_map_array), error);
++ // device bottom half
++ bus->device_bh.routine = usbd_device_bh;
++ bus->device_bh.data = bus;
++ bus->status = USBD_OK;
++ bus->bus_state = usbd_bus_state_enabled;
++ bus->ep0->endpoint_map_array->endpoint = bus->endpoint_array;
++ THROW_IF (usbd_function_enable (bus, bus->ep0), error);
++
++ //printk(KERN_INFO"%s: %d endpoint: %p map: %p\n", __FUNCTION__, 0,
++ // bus->ep0->endpoint_map_array->endpoint,
++ // bus->ep0->endpoint_map_array);
++
++ // iterate across the logical endpoint map to copy appropriate information
++ // into the physical endpoint instance array
++
++ for (epn = 0; epn < bus->function_instance->endpointsRequested; epn++) {
++
++ struct usb_endpoint_map *endpoint_map = bus->function_instance->endpoint_map_array + epn;
++ int physicalEndpoint = endpoint_map->physicalEndpoint[0];
++ struct usb_endpoint_instance *endpoint = bus->endpoint_array + physicalEndpoint;
++
++ //printk(KERN_INFO"%s: %d endpoint: %p map: %p bEndpointAddress: %02x\n", __FUNCTION__,
++ // epn, endpoint, endpoint_map, endpoint_map->bEndpointAddress[0]);
++
++ endpoint_map->endpoint = endpoint;
++ endpoint->bEndpointAddress = endpoint_map->bEndpointAddress[0];
++ endpoint->bmAttributes = endpoint_map->bmAttributes[0];
++
++ switch(endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
++ case USB_DIR_IN:
++ endpoint->wMaxPacketSize = endpoint_map->wMaxPacketSize[0];
++ endpoint->last = 0;
++ endpoint->tx_urb = NULL;
++ break;
++
++ case USB_DIR_OUT:
++ endpoint->rcv_transferSize = endpoint_map->transferSize[0];
++ endpoint->wMaxPacketSize = endpoint_map->wMaxPacketSize[0];
++ endpoint->rcv_urb = NULL;
++ break;
++ }
++ }
++
++ rc = 0;
++
++ CATCH(error) {
++ printk(KERN_INFO"%s: FAILED\n", __FUNCTION__);
++ usbd_strings_exit();
++ }
++ up(&usbd_bus_sem);
++ //printk(KERN_INFO"%s: UP USBD_BUS_SEM\n", __FUNCTION__);
++ return rc;
++}
++
++/* usbd_disable_function - called to disable the current function
++ *
++ * Used by a USB Bus interface driver to destroy a virtual device.
++ */
++void usbd_disable_function (struct usb_bus_instance *bus)
++{
++ printk(KERN_INFO"%s: DOWN USBD_BUS_SEM\n", __FUNCTION__);
++ down(&usbd_bus_sem);
++ // prevent any more bottom half scheduling
++ bus->status = USBD_CLOSING;
++ up(&usbd_bus_sem);
++ //printk(KERN_INFO"%s: UP USBD_BUS_SEM\n", __FUNCTION__);
++
++ // wait for pending device bottom half to finish
++ while (bus->device_bh.data /*|| device->function_bh.data */) {
++
++ //printk(KERN_INFO"%s: waiting for usbd_device_bh %ld %p interrupt: %d\n", __FUNCTION__,
++ // bus->device_bh.sync, bus->device_bh.data, in_interrupt());
++
++ // This can probably be either, but for consistency's sake...
++ queue_task(&bus->device_bh, &tq_immediate);
++ mark_bh (IMMEDIATE_BH);
++ // schedule_task(&device->device_bh);
++
++ schedule_timeout (2000 * HZ);
++ }
++
++ //printk(KERN_INFO"%s: DOWN USBD_BUS_SEM\n", __FUNCTION__);
++ down(&usbd_bus_sem);
++
++ // tell the function driver to close
++ usbd_function_disable (bus->ep0);
++ usbd_function_disable (bus->function_instance);
++
++ // free alternates memory
++ if (/*bus->bNumInterfaces &&*/ bus->alternates) {
++ bus->bNumInterfaces = 0;
++ lkfree(bus->alternates);
++ bus->alternates = NULL;
++ }
++ if (bus->function_instance) {
++ if (bus->function_instance->endpoint_map_array)
++ lkfree(bus->function_instance->endpoint_map_array);
++ lkfree(bus->function_instance);
++ bus->function_instance = NULL;
++ }
++ usbd_strings_exit();
++ bus->status = USBD_CLOSED;
++ up(&usbd_bus_sem);
++ printk(KERN_INFO"%s: UP USBD_BUS_SEM\n", __FUNCTION__);
++}
++
++usb_device_state_t usbd_device_state(struct usb_function_instance *function)
++{
++ //printk(KERN_INFO"%s: %d\n", __FUNCTION__, function->bus->device_state);
++ return (function && function->bus) ? function->bus->device_state : STATE_UNKNOWN;
++}
++usb_device_state_t usbd_bus_state(struct usb_function_instance *function)
++{
++ //printk(KERN_INFO"%s: %d\n", __FUNCTION__, function->bus->bus_state);
++ return (function && function->bus) ? function->bus->bus_state : usbd_bus_state_unknown;
++}
++usb_device_status_t usbd_bus_status(struct usb_function_instance *function)
++{
++ //printk(KERN_INFO"%s: %d\n", __FUNCTION__, function->bus->status);
++ return (function && function->bus) ? function->bus->status : USBD_UNKNOWN;
++}
++
++EXPORT_SYMBOL(usbd_register_bus);
++EXPORT_SYMBOL(usbd_deregister_bus);
++EXPORT_SYMBOL(usbd_enable_function_irq);
++EXPORT_SYMBOL(usbd_disable_function);
++EXPORT_SYMBOL(usbd_attached);
++EXPORT_SYMBOL(usbd_send_urb);
++EXPORT_SYMBOL(usbd_start_recv);
++EXPORT_SYMBOL(usbd_flush_endpoint);
++EXPORT_SYMBOL(usbd_cancel_urb_irq);
++EXPORT_SYMBOL(usbd_bus_event_irq);
++EXPORT_SYMBOL(usbd_bus_event);
++EXPORT_SYMBOL(usbd_urb_sent_finished_irq);
++EXPORT_SYMBOL(usbd_urb_recv_finished_irq);
++EXPORT_SYMBOL(usbd_device_state);
++EXPORT_SYMBOL(usbd_bus_state);
++EXPORT_SYMBOL(usbd_bus_status);
++EXPORT_SYMBOL(usbd_first_urb_detached_irq);
++
+diff -Nru a/drivers/usbd/usbd-build.h b/drivers/usbd/usbd-build.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-build.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1 @@
++#define USBD_BUILD "000"
+diff -Nru a/drivers/usbd/usbd-bus.h b/drivers/usbd/usbd-bus.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-bus.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,316 @@
++/*
++ * usbd/usbd-bus.c - USB Device Bus Interface Driver Interface
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++/*
++ * This file contains the USB Bus Interface Driver Interface definitions.
++ *
++ * This is the interface between the bottom of the USB Core and the top of
++ * the Bus Interace Drivers and is comprised of:
++ *
++ * o public functions exported by the USB Core layer
++ *
++ * o structures and functions passed by the Function Driver to the USB
++ * Core layer
++ *
++ * USB Bus Interface Drivers are structured such that the upper edge
++ * implements interfaces to the USB Core layer to provide low level USB
++ * services and the lower edge interfaces to the actual USB Hardware
++ * (typically called the USB Device Controller or UDC.)
++ *
++ */
++
++struct usb_endpoint_map;
++
++/* Operations that the slave layer or function driver can use to interact
++ * with the bus interface driver.
++ *
++ * The send_urb() function is used by the usb-device endpoint 0 driver and
++ * function drivers to submit data to be sent.
++ *
++ * The cancel_urb() function is used by the usb-device endpoint 0 driver and
++ * function drivers to remove previously queued data to be sent.
++ *
++ * The endpoint_halted() function is used by the ep0 control function to
++ * check if an endpoint is halted.
++ *
++ * The device_feature() function is used by the ep0 control function to
++ * set/reset device features on an endpoint.
++ *
++ * The device_event() function is used by the usb device core to tell the
++ * bus interface driver about various events.
++ */
++struct usb_bus_operations {
++ int (*bus_enable) (struct usb_bus_instance *, char *);
++ int (*bus_disable) (struct usb_bus_instance *, char *);
++ int (*bus_disconnect) (struct usb_bus_instance *, char *);
++ int (*bus_connect) (struct usb_bus_instance *, char *);
++ int (*bus_pm_off) (struct usb_bus_instance *, char *);
++ int (*bus_pm_on) (struct usb_bus_instance *, char *);
++ int (*bus_serial_number) (struct usb_bus_instance *, char *);
++
++ int (*bus_attached) (struct usb_bus_instance *);
++ int (*bus_connected) (struct usb_bus_instance *);
++ int (*start_endpoint_in) (struct usb_bus_instance *, struct usb_endpoint_instance *);
++ int (*start_endpoint_out) (struct usb_bus_instance *, struct usb_endpoint_instance *);
++ int (*cancel_urb_irq) (struct urb *);
++ int (*endpoint_halted) (struct usb_bus_instance *, int);
++ int (*device_feature) (struct usb_bus_instance *, int, int);
++ int (*device_event) (struct usb_bus_instance *, usb_device_event_t, int);
++ int (*request_endpoints) (struct usb_endpoint_map *, int, struct usb_endpoint_request *);
++ int (*set_endpoints) (int , struct usb_endpoint_map *);
++};
++
++
++/* Endpoint Map
++ *
++ * An array of these structures is created by the bus interface driver to
++ * show what endpoints have been configured for the function driver.
++ */
++struct usb_endpoint_map {
++ u8 configuration;
++ u8 interface;
++ u8 alternate;
++ u8 bEndpointAddress[2]; // logical endpoint address
++ u16 wMaxPacketSize[2]; // packetsSize for requested endpoint
++ u8 bmAttributes[2]; // requested endpoint type
++ u16 transferSize[2]; // transferSize for bulk transfers
++ u8 physicalEndpoint[2]; // physical endpoint number
++ struct usb_endpoint_instance *endpoint;
++};
++
++
++/* Endpoint configuration
++ *
++ * Per endpoint configuration data. Used to track which function driver owns
++ * an endpoint.
++ *
++ */
++struct usb_endpoint_instance {
++ int bEndpointAddress; // logical endpoint address
++ int physical_endpoint; // physical endpoint address - bus interface specific
++ int bmAttributes; // endpoint type
++ u16 wMaxPacketSize; // packet size for requested endpoint
++
++ // control
++ int status; // halted
++ int state; // available for use by bus interface driver
++
++ // receive side
++ struct urb_link rcv; // received urbs
++ struct urb_link rdy; // empty urbs ready to receive
++ struct urb *rcv_urb; // active urb
++ __u32 rcv_transferSize; // maximum transfer size from function driver
++ int rcv_error; // current bulk-in has an error
++
++ // transmit side
++ struct urb_link tx; // urbs ready to transmit
++ struct urb_link done; // transmitted urbs
++ struct urb *tx_urb; // active urb
++
++ __u32 sent; // data already sent
++ __u32 last; // data sent in last packet XXX do we need this
++};
++
++/* endpoint zero states
++ */
++#define WAIT_FOR_SETUP 0
++#define DATA_STATE_XMIT 1
++#define DATA_STATE_NEED_ZLP 2
++#define WAIT_FOR_OUT_STATUS 3
++#define DATA_STATE_RECV 4
++#define DATA_STATE_PENDING_XMIT 5
++
++
++/* Bus Interface data structure
++ *
++ * Keep track of specific bus interface.
++ *
++ * This is passed to the usb-device layer when registering. It contains all
++ * required information about each real bus interface found such that the
++ * usb-device layer can create and maintain a usb-device structure.
++ *
++ * Note that bus interface registration is incumbent on finding specific
++ * actual real bus interfaces. There will be a registration for each such
++ * device found.
++ *
++ * The max_tx_endpoints and max_rx_endpoints are the maximum number of
++ * possible endpoints that this bus interface can support. The default
++ * endpoint 0 is not included in these counts.
++ *
++ */
++struct usb_bus_driver {
++ char *name;
++ u8 max_endpoints; // maximimum number of rx enpoints
++ u8 maxpacketsize;
++ u8 HighSpeedCapable;
++ struct usb_device_description *device_description;
++ struct usb_bus_operations *bops;
++};
++
++
++typedef enum usbd_admin {
++ usbd_admin_enable = 0,
++ usbd_admin_disable = 1,
++ usbd_admin_connect = 2,
++ usbd_admin_disconnect = 3,
++ usbd_admin_pm_off = 4,
++ usbd_admin_pm_on = 5,
++ usbd_admin_serial_number = 6
++} usbd_admin_t;
++
++typedef int (*usbd_admin_proc_t) (struct usb_bus_instance *, char *);
++
++
++/* Function configuration structure
++ *
++ * This is allocated for each configured instance of a function driver.
++ *
++ * It stores pointers to the usb_function_driver for the appropriate function,
++ * and pointers to the USB HOST requested usb_configuration_description and
++ * usb_interface_description.
++ *
++ * The privdata pointer may be used by the function driver to store private
++ * per instance state information.
++ *
++ */
++struct usb_function_instance {
++ struct usb_bus_instance *bus;
++ struct usb_function_driver *function_driver;
++ void *privdata; // private data for the function
++ __u8 endpointsRequested; // number of requested endpoints
++ struct usb_endpoint_map *endpoint_map_array; // map of endpoints requested by function driver
++};
++
++
++/* Bus Interface configuration structure
++ *
++ * This is allocated for each configured instance of a bus interface driver.
++ *
++ * It contains a pointer to the appropriate bus interface driver.
++ *
++ * The privdata pointer may be used by the bus interface driver to store private
++ * per instance state information.
++ */
++struct usb_bus_instance {
++
++ struct usb_bus_driver *driver;
++
++ usbd_admin_proc_t admin [8];
++
++ int endpoints;
++ struct usb_endpoint_instance *endpoint_array; // array of available configured endpoints
++
++ char *serial_number_str;
++
++ usb_device_status_t status; // device status
++ usbd_bus_state_t bus_state;
++ usb_device_state_t device_state; // current USB Device state
++ usb_device_state_t suspended_state; // previous USB Device state
++
++ struct usb_function_instance *ep0; // ep0 configuration
++ struct usb_function_instance *function_instance;
++
++
++ u8 HighSpeedFlag;
++ u8 ConfigurationValue; // current set configuration (zero is default)
++ u8 bNumInterfaces; // number of interfaces in the current configuration
++ u8 *alternates; // array[0..interfaces-1] of alternate settings for each interface
++
++ struct tq_struct device_bh; // runs as bottom half, equivalent to interrupt time
++
++ void *privdata; // private data for the bus interface
++ char *arg;
++};
++
++/* bus driver registration
++ *
++ * Called by bus interface drivers to register themselves when loaded
++ * or de-register when unloading.
++ */
++struct usb_bus_instance *usbd_register_bus (struct usb_bus_driver *);
++void usbd_deregister_bus (struct usb_bus_instance *);
++
++
++
++/* Enable/Disable Function
++ *
++ * Called by a bus interface driver to select and enable a specific function
++ * driver.
++ */
++int usbd_enable_function_irq (struct usb_bus_instance *, char *);
++void usbd_disable_function (struct usb_bus_instance *);
++
++
++void usbd_flush_endpoint_irq (struct usb_endpoint_instance *);
++void usbd_flush_endpoint (struct usb_endpoint_instance *);
++
++/*
++ * usbd_configure_device is used by function drivers (usually the control endpoint)
++ * to change the device configuration.
++ *
++ * usbd_device_event is used by bus interface drivers to tell the higher layers that
++ * certain events have taken place.
++ */
++void usbd_bus_event_irq (struct usb_bus_instance *, usb_device_event_t, int);
++void usbd_bus_event (struct usb_bus_instance *, usb_device_event_t, int);
++
++
++/**
++ * usbd_recv_setup_irq - process a received urb
++ * @urb: pointer to an urb structure
++ *
++ * Used by a USB Bus interface driver to pass received data in a URB to the
++ * appropriate USB Function driver.
++ *
++ * This function must return 0 for success and -EINVAL if the request
++ * is to be stalled.
++ *
++ * Not that if the SETUP is Host to Device with a non-zero wLength then there
++ * *MUST* be a valid receive urb queued OR the request must be stalled.
++ */
++int usbd_recv_setup_irq (struct usb_function_instance*, struct usb_device_request *);
++
++
++void usbd_urb_sent_finished_irq (struct urb *, int );
++void usbd_urb_recv_finished_irq (struct urb *, int );
++
++
++/*
++ * Detach and return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ */
++struct urb *usbd_first_urb_detached_irq (urb_link * hd);
++
++/*
++ * Get a descriptor
++ */
++int usbd_get_descriptor (struct usb_bus_instance *bus, u8 *buffer, int max, int descriptor_type, int index);
++
+diff -Nru a/drivers/usbd/usbd-chap9.h b/drivers/usbd/usbd-chap9.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-chap9.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,1054 @@
++/*
++ * usbd/usbd-chap9.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++/*
++ * USB Descriptors are used to build a configuration database for each USB
++ * Function driver.
++ *
++ */
++
++
++/*
++ * Device and/or Interface Class codes
++ */
++#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
++#define USB_CLASS_AUDIO 1
++#define USB_CLASS_COMM 2
++#define USB_CLASS_HID 3
++#define USB_CLASS_PHYSICAL 5
++#define USB_CLASS_PRINTER 7
++#define USB_CLASS_MASS_STORAGE 8
++#define USB_CLASS_HUB 9
++#define USB_CLASS_DATA 10
++#define USB_CLASS_APP_SPEC 0xfe
++#define USB_CLASS_VENDOR_SPEC 0xff
++
++/*
++ * USB Device Request Types (bmRequestType)
++ * C.f. USB 2.0 Table 9-2
++ */
++#define USB_TYPE_STANDARD (0x00 << 5)
++#define USB_TYPE_CLASS (0x01 << 5)
++#define USB_TYPE_VENDOR (0x02 << 5)
++#define USB_TYPE_RESERVED (0x03 << 5)
++
++#define USB_RECIP_DEVICE 0x00
++#define USB_RECIP_INTERFACE 0x01
++#define USB_RECIP_ENDPOINT 0x02
++#define USB_RECIP_OTHER 0x03
++
++#define USB_DIR_OUT 0
++#define USB_DIR_IN 0x80
++#define USB_ENDPOINT_OPT 0x40
++
++
++
++/*
++ * Descriptor types
++ * C.f. USB Table 9-5
++ */
++#define USB_DT_DEVICE 0x01
++#define USB_DT_CONFIG 0x02
++#define USB_DT_STRING 0x03
++#define USB_DT_INTERFACE 0x04
++#define USB_DT_ENDPOINT 0x05
++
++
++
++#define USB_DT_HID (USB_TYPE_CLASS | 0x01)
++#define USB_DT_REPORT (USB_TYPE_CLASS | 0x02)
++#define USB_DT_PHYSICAL (USB_TYPE_CLASS | 0x03)
++#define USB_DT_HUB (USB_TYPE_CLASS | 0x09)
++
++/*
++ * Descriptor sizes per descriptor type
++ */
++#define USB_DT_DEVICE_SIZE 18
++#define USB_DT_CONFIG_SIZE 9
++#define USB_DT_INTERFACE_SIZE 9
++#define USB_DT_ENDPOINT_SIZE 7
++#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
++#define USB_DT_HUB_NONVAR_SIZE 7
++#define USB_DT_HID_SIZE 9
++
++/*
++ * Endpoints
++ */
++#define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */
++#define USB_ENDPOINT_DIR_MASK 0x80
++
++#define USB_ENDPOINT_MASK 0x03 /* in bmAttributes */
++#define USB_ENDPOINT_CONTROL 0x00
++#define USB_ENDPOINT_ISOCHRONOUS 0x01
++#define USB_ENDPOINT_BULK 0x02
++#define USB_ENDPOINT_INTERRUPT 0x03
++
++/*
++ * USB Packet IDs (PIDs)
++ */
++#define USB_PID_UNDEF_0 0xf0
++#define USB_PID_OUT 0xe1
++#define USB_PID_ACK 0xd2
++#define USB_PID_DATA0 0xc3
++#define USB_PID_PING 0xb4 /* USB 2.0 */
++#define USB_PID_SOF 0xa5
++#define USB_PID_NYET 0x96 /* USB 2.0 */
++#define USB_PID_DATA2 0x87 /* USB 2.0 */
++#define USB_PID_SPLIT 0x78 /* USB 2.0 */
++#define USB_PID_IN 0x69
++#define USB_PID_NAK 0x5a
++#define USB_PID_DATA1 0x4b
++#define USB_PID_PREAMBLE 0x3c /* Token mode */
++#define USB_PID_ERR 0x3c /* USB 2.0: handshake mode */
++#define USB_PID_SETUP 0x2d
++#define USB_PID_STALL 0x1e
++#define USB_PID_MDATA 0x0f /* USB 2.0 */
++
++/*
++ * Standard requests
++ */
++#define USB_REQ_GET_STATUS 0x00
++#define USB_REQ_CLEAR_FEATURE 0x01
++#define USB_REQ_SET_FEATURE 0x03
++#define USB_REQ_SET_ADDRESS 0x05
++#define USB_REQ_GET_DESCRIPTOR 0x06
++#define USB_REQ_SET_DESCRIPTOR 0x07
++#define USB_REQ_GET_CONFIGURATION 0x08
++#define USB_REQ_SET_CONFIGURATION 0x09
++#define USB_REQ_GET_INTERFACE 0x0A
++#define USB_REQ_SET_INTERFACE 0x0B
++#define USB_REQ_SYNCH_FRAME 0x0C
++
++/*
++ * HID requests
++ */
++#define USB_REQ_GET_REPORT 0x01
++#define USB_REQ_GET_IDLE 0x02
++#define USB_REQ_GET_PROTOCOL 0x03
++#define USB_REQ_SET_REPORT 0x09
++#define USB_REQ_SET_IDLE 0x0A
++#define USB_REQ_SET_PROTOCOL 0x0B
++
++
++/*
++ * USB Spec Release number
++ */
++
++#define USB_BCD_VERSION 0x0200
++
++/*
++ * Audio
++ */
++#define CS_AUDIO_UNDEFINED 0x20
++#define CS_AUDIO_DEVICE 0x21
++#define CS_AUDIO_CONFIGURATION 0x22
++#define CS_AUDIO_STRING 0x23
++#define CS_AUDIO_INTERFACE 0x24
++#define CS_AUDIO_ENDPOINT 0x25
++
++#define AUDIO_HEADER 0x01
++#define AUDIO_INPUT_TERMINAL 0x02
++#define AUDIO_OUTPUT_TERMINAL 0x03
++#define AUDIO_MIXER_UNIT 0x04
++#define AUDIO_SELECTOR_UNIT 0x05
++#define AUDIO_FEATURE_UNIT 0x06
++#define AUDIO_PROCESSING_UNIT 0x07
++#define AUDIO_EXTENSION_UNIT 0x08
++
++
++/*
++ * Device Requests (c.f Table 9-2)
++ */
++
++#define USB_REQ_DIRECTION_MASK 0x80
++#define USB_REQ_TYPE_MASK 0x60
++#define USB_REQ_RECIPIENT_MASK 0x1f
++
++#define USB_REQ_DEVICE2HOST 0x80
++#define USB_REQ_HOST2DEVICE 0x00
++
++#define USB_REQ_TYPE_STANDARD 0x00
++#define USB_REQ_TYPE_CLASS 0x20
++#define USB_REQ_TYPE_VENDOR 0x40
++
++#define USB_REQ_RECIPIENT_DEVICE 0x00
++#define USB_REQ_RECIPIENT_INTERFACE 0x01
++#define USB_REQ_RECIPIENT_ENDPOINT 0x02
++#define USB_REQ_RECIPIENT_OTHER 0x03
++
++/*
++ * get status bits
++ */
++
++#define USB_STATUS_SELFPOWERED 0x01
++#define USB_STATUS_REMOTEWAKEUP 0x02
++
++#define USB_STATUS_HALT 0x01
++
++/*
++ * descriptor types
++ */
++
++#define USB_DESCRIPTOR_TYPE_DEVICE 0x01
++#define USB_DESCRIPTOR_TYPE_CONFIGURATION 0x02
++#define USB_DESCRIPTOR_TYPE_STRING 0x03
++#define USB_DESCRIPTOR_TYPE_INTERFACE 0x04
++#define USB_DESCRIPTOR_TYPE_ENDPOINT 0x05
++#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 0x06
++#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION 0x07
++#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 0x08
++
++/*
++ * standard feature selectors
++ */
++#define USB_ENDPOINT_HALT 0x00
++#define USB_DEVICE_REMOTE_WAKEUP 0x01
++#define USB_TEST_MODE 0x02
++
++
++/* USB Requests
++ *
++ */
++
++struct usb_device_request {
++ __u8 bmRequestType;
++ __u8 bRequest;
++ __u16 wValue;
++ __u16 wIndex;
++ __u16 wLength;
++} __attribute__ ((packed));
++
++
++/*
++ * Class-Specific Request Codes
++ * C.f. CDC Table 46
++ */
++#define CDC_CLASS_REQUEST_SEND_ENCAPSULATED 0x00
++#define CDC_CLASS_REQUEST_GET_ENCAPSULATED 0x01
++
++#define CDC_CLASS_REQUEST_SET_COMM_FEATURE 0x02
++#define CDC_CLASS_REQUEST_GET_COMM_FEATURE 0x03
++#define CDC_CLASS_REQUEST_CLEAR_COMM_FEATURE 0x04
++
++#define CDC_CLASS_REQUEST_SET_LINE_CODING 0x20
++#define CDC_CLASS_REQUEST_GET_LINE_CODING 0x21
++
++#define CDC_CLASS_REQUEST_SET_CONTROL_STATE 0x22
++#define CDC_CLASS_REQUEST_SEND_BREAK 0x23
++
++/*
++ * Notification codes
++ * c.f. CDC Table 68
++ */
++
++#define CDC_NOTIFICATION_NETWORK_CONNECTION 0x00
++#define CDC_NOTIFICATION_RESPONSE_AVAILABLE 0x01
++#define CDC_NOTIFICATION_AUX_JACK_HOOK_STATE 0x08
++#define CDC_NOTIFICATION_RING_DETECT 0x09
++#define CDC_NOTIFICATION_SERIAL_STATE 0x20
++#define CDC_NOTIFICATION_CALL_STATE_CHANGE 0x28
++#define CDC_NOTIFICATION_LINE_STATE_CHANGE 0x29
++#define CDC_NOTIFICATION_CONNECTION_SPEED_CHANGE 0x2a
++
++/*
++ * HID - Class Descriptors
++ * C.f. 7.1.1
++ */
++#define HID 0x21
++#define HID_REPORT 0x22
++#define HID_PHYSICAL 0x23
++
++/*
++ * HID Descriptor
++ * C.f. E.8
++ */
++struct hid_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u16 bcdHID;
++ u8 bCountryCode;
++ u8 bNumDescriptors;
++ u8 bReportType;
++ u16 wItemLength;
++} __attribute__((packed));
++
++/*
++ * ACM - Line Coding structure
++ * C.f CDC Table 50
++ */
++struct cdc_acm_line_coding {
++ __u32 dwDTERate;
++ __u8 bCharFormat;
++ __u8 bParityType;
++ __u8 bDataBits;
++} __attribute__((packed));
++
++/*
++ * ACM
++ * C.f CDC Table 50
++ */
++
++
++/*
++ * ACM
++ * C.f CDC Table 51
++ */
++
++
++/* USB Notification
++ *
++ */
++
++struct cdc_notification_descriptor {
++ __u8 bmRequestType;
++ __u8 bNotification;
++ __u16 wValue;
++ __u16 wIndex;
++ __u16 wLength;
++ __u8 data[2];
++} __attribute__ ((packed));
++
++
++
++
++/*
++ * communications class types
++ *
++ * c.f. CDC USB Class Definitions for Communications Devices
++ * c.f. WMCD USB CDC Subclass Specification for Wireless Mobile Communications Devices
++ *
++ */
++
++#define CLASS_BCD_VERSION 0x0110
++
++// c.f. CDC 4.1 Table 14
++#define AUDIO_CLASS 0x01
++#define COMMUNICATIONS_DEVICE_CLASS 0x02
++
++// c.f. CDC 4.2 Table 15
++#define COMMUNICATIONS_INTERFACE_CLASS 0x02
++
++// c.f. CDC 4.3 Table 16
++#define COMMUNICATIONS_NO_SUBCLASS 0x00
++#define COMMUNICATIONS_DLCM_SUBCLASS 0x01
++#define COMMUNICATIONS_ACM_SUBCLASS 0x02
++#define COMMUNICATIONS_TCM_SUBCLASS 0x03
++#define COMMUNICATIONS_MCCM_SUBCLASS 0x04
++#define COMMUNICATIONS_CCM_SUBCLASS 0x05
++#define COMMUNICATIONS_ENCM_SUBCLASS 0x06
++#define COMMUNICATIONS_ANCM_SUBCLASS 0x07
++
++#define AUDIO_CONTROL_SUBCLASS 0x01
++#define AUDIO_STREAMING_SUBCLASS 0x02
++
++// c.f. WMCD 5.1
++#define COMMUNICATIONS_WHCM_SUBCLASS 0x08
++#define COMMUNICATIONS_DMM_SUBCLASS 0x09
++#define COMMUNICATIONS_MDLM_SUBCLASS 0x0a
++#define COMMUNICATIONS_OBEX_SUBCLASS 0x0b
++
++// c.f. CDC 4.6 Table 18
++#define DATA_INTERFACE_CLASS 0x0a
++
++// c.f. CDC 4.7 Table 19
++#define COMMUNICATIONS_NO_PROTOCOL 0x00
++
++
++// c.f. CDC 5.2.3 Table 24
++// c.f. Audio Appendix A.4
++#define CS_UNDEFINED 0x20
++#define CS_DEVICE 0x21
++#define CS_CONFIG 0x22
++#define CS_STRING 0x23
++#define CS_INTERFACE 0x24
++#define CS_ENDPOINT 0x25
++
++// Audio Interface Class - c.f Appendix A.1
++#define AUDIO_INTERFACE_CLASS 0x01
++
++// Audio Interface Subclass - c.f Appendix A.2
++#define AUDIO_SUBCLASS_UNDEFINED 0x00
++#define AUDIO_AUDIOCONTROL 0x01
++#define AUDIO_AUDIOSTREAMING 0x02
++#define AUDIO_MIDISTREAMING 0x03
++
++// Audio Interface Proctol - c.f. Appendix A.3
++#define AUDIO_PR_PROTOCOL_UNDEFINED 0x00
++
++// Audio Class-Specific AC Interface Descriptor Subtypes - c.f. A.5
++#define AUDIO_AC_DESCRIPTOR_UNDEFINED 0x00
++#define AUDIO_AC_HEADER 0x01
++#define AUDIO_AC_INPUT_TERMINAL 0x02
++#define AUDIO_AC_OUTPUT_TERMINAL 0x03
++#define AUDIO_AC_MIXER_UNIT 0x04
++#define AUDIO_AC_SELECTOR_UNIT 0x05
++#define AUDIO_AC_FEATURE_UNIT 0x06
++#define AUDIO_AC_PROCESSING_UNIT 0x07
++#define AUDIO_AC_EXTENSION_UNIT 0x08
++
++// Audio Class-Specific AS Interface Descriptor Subtypes - c.f. A.6
++#define AUDIO_AS_DESCRIPTOR_UNDEFINED 0x00
++#define AUDIO_AS_GENERAL 0x01
++#define AUDIO_AS_FORMAT_TYPE 0x02
++#define AUDIO_AS_FORMAT_UNSPECFIC 0x03
++
++// Audio Class Processing Unit Processing Types - c.f. A.7
++#define AUDIO_PROCESS_UNDEFINED 0x00
++#define AUDIO_UP_DOWN_MUIX_PROCESS 0x01
++#define AUDIO_DOLBY_PROLOGIC_PROCESS 0x02
++#define AUDIO_3D_STEREO_EXTENDER_PROCESS 0x03
++#define AUDIO_REVERBERATION_PROCESS 0x04
++#define AUDIO_CHORUS_PROCESS 0x05
++#define AUDIO_DYN_RANGE_COMP_PROCESS 0x06
++
++// Audio Class-Specific Endpoint Descriptor Subtypes - c.f. A.8
++#define AUDIO_DESCRIPTOR_UNDEFINED 0x00
++#define AUDIO_EP_GENERAL 0x01
++
++// Audio Class-Specific Request Codes - c.f. A.9
++#define AUDIO_REQUEST_CODE_UNDEFINED 0x00
++#define AUDIO_SET_CUR 0x01
++#define AUDIO_GET_CUR 0x81
++#define AUDIO_SET_MIN 0x02
++#define AUDIO_GET_MIN 0x82
++#define AUDIO_SET_MAX 0x03
++#define AUDIO_GET_MAX 0x83
++#define AUDIO_SET_RES 0x04
++#define AUDIO_GET_RES 0x84
++#define AUDIO_SET_MEM 0x05
++#define AUDIO_GET_MEM 0x85
++#define AUDIO_GET_STAT 0xff
++
++
++
++
++
++
++/*
++ * bDescriptorSubtypes
++ *
++ * c.f. CDC 5.2.3 Table 25
++ * c.f. WMCD 5.3 Table 5.3
++ */
++
++#define USB_ST_HEADER 0x00
++#define USB_ST_CMF 0x01
++#define USB_ST_ACMF 0x02
++#define USB_ST_DLMF 0x03
++#define USB_ST_TRF 0x04
++#define USB_ST_TCLF 0x05
++#define USB_ST_UF 0x06
++#define USB_ST_CSF 0x07
++#define USB_ST_TOMF 0x08
++#define USB_ST_USBTF 0x09
++#define USB_ST_NCT 0x0a
++#define USB_ST_PUF 0x0b
++#define USB_ST_EUF 0x0c
++#define USB_ST_MCMF 0x0d
++#define USB_ST_CCMF 0x0e
++#define USB_ST_ENF 0x0f
++#define USB_ST_ATMNF 0x10
++
++#define USB_ST_WHCM 0x11
++#define USB_ST_MDLM 0x12
++#define USB_ST_MDLMD 0x13
++#define USB_ST_DMM 0x14
++#define USB_ST_OBEX 0x15
++#define USB_ST_CS 0x16
++#define USB_ST_CSD 0x17
++#define USB_ST_TCM 0x18
++
++
++
++/*
++ * commuications class description structures
++ *
++ * c.f. CDC 5.1
++ * c.f. WCMC 6.7.2
++ *
++ * XXX add the other dozen class descriptor description structures....
++ */
++
++struct usb_header_description {
++ __u8 bDescriptorSubtype;
++ __u16 bcdCDC;
++};
++
++struct usb_call_management_description {
++ __u8 bmCapabilities;
++ __u8 bDataInterface;
++};
++
++struct usb_abstract_control_description {
++ __u8 bmCapabilities;
++};
++
++struct usb_union_function_description {
++ __u8 bMasterInterface;
++ __u8 bSlaveInterface[1];
++ //__u8 bSlaveInterface[0]; // XXX FIXME
++};
++
++struct usb_ethernet_networking_description {
++ char *iMACAddress;
++ __u8 bmEthernetStatistics;
++ __u16 wMaxSegmentSize;
++ __u16 wNumberMCFilters;
++ __u8 bNumberPowerFilters;
++};
++
++struct usb_mobile_direct_line_model_description {
++ __u16 bcdVersion;
++ __u8 bGUID[16];
++};
++
++struct usb_mobile_direct_line_model_detail_description {
++ __u8 bGuidDescriptorType;
++ __u8 bDetailData[2];
++ //__u8 bDetailData[0]; // XXX FIXME
++};
++
++struct usb_class_description {
++ __u8 bDescriptorSubtype;
++ __u8 elements;
++ union {
++ struct usb_header_description header;
++ struct usb_call_management_description call_management;
++ struct usb_abstract_control_description abstract_control;
++ struct usb_union_function_description union_function;
++ struct usb_ethernet_networking_description ethernet_networking;
++ struct usb_mobile_direct_line_model_description mobile_direct;
++ struct usb_mobile_direct_line_model_detail_description mobile_direct_detail;
++ } description;
++};
++
++/* endpoint modifiers
++ * static struct usb_endpoint_description function_default_A_1[] = {
++ *
++ * {this_endpoint: 0, attributes: CONTROL, max_size: 8, polling_interval: 0 },
++ * {this_endpoint: 1, attributes: BULK, max_size: 64, polling_interval: 0, direction: IN},
++ * {this_endpoint: 2, attributes: BULK, max_size: 64, polling_interval: 0, direction: OUT},
++ * {this_endpoint: 3, attributes: INTERRUPT, max_size: 8, polling_interval: 0},
++ *
++ *
++ */
++#define OUT 0x00
++#define IN 0x80
++
++#define CONTROL 0x00
++#define ISOCHRONOUS 0x01
++#define BULK 0x02
++#define INTERRUPT 0x03
++
++
++/* configuration modifiers
++ */
++#define BMATTRIBUTE_RESERVED 0x80
++#define BMATTRIBUTE_SELF_POWERED 0x40
++
++/*
++ * The UUT tester specifically tests for MaxPower to be non-zero (> 0).
++ */
++#if !defined(CONFIG_USBD_MAXPOWER) || (CONFIG_USBD_MAXPOWER == 0)
++ #define BMATTRIBUTE BMATTRIBUTE_RESERVED | BMATTRIBUTE_SELF_POWERED
++ #define BMAXPOWER 1
++#else
++ #define BMATTRIBUTE BMATTRIBUTE_RESERVED
++ #define BMAXPOWER CONFIG_USBD_MAXPOWER
++#endif
++
++
++
++
++/*
++ * standard usb descriptor structures
++ */
++
++struct usb_endpoint_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType; // 0x5
++ __u8 bEndpointAddress;
++ __u8 bmAttributes;
++ __u16 wMaxPacketSize;
++ __u8 bInterval;
++} __attribute__ ((packed));
++
++struct usb_interface_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType; // 0x04
++ __u8 bInterfaceNumber;
++ __u8 bAlternateSetting;
++ __u8 bNumEndpoints;
++ __u8 bInterfaceClass;
++ __u8 bInterfaceSubClass;
++ __u8 bInterfaceProtocol;
++ __u8 iInterface;
++} __attribute__ ((packed));
++
++struct usb_configuration_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType; // 0x2
++ __u16 wTotalLength;
++ __u8 bNumInterfaces;
++ __u8 bConfigurationValue;
++ __u8 iConfiguration;
++ __u8 bmAttributes;
++ __u8 bMaxPower;
++} __attribute__ ((packed));
++
++struct usb_device_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType; // 0x01
++ __u16 bcdUSB;
++ __u8 bDeviceClass;
++ __u8 bDeviceSubClass;
++ __u8 bDeviceProtocol;
++ __u8 bMaxPacketSize0;
++ __u16 idVendor;
++ __u16 idProduct;
++ __u16 bcdDevice;
++ __u8 iManufacturer;
++ __u8 iProduct;
++ __u8 iSerialNumber;
++ __u8 bNumConfigurations;
++} __attribute__ ((packed));
++
++struct usb_string_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType; // 0x03
++ __u16 wData[0];
++} __attribute__ ((packed));
++
++struct usb_device_qualifier_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++ __u16 bcdUSB;
++ __u8 bDeviceClass;
++ __u8 bDeviceSubClass;
++ __u8 bDeviceProtocol;
++ __u8 bMaxPacketSize0;
++ __u8 bNumConfigurations;
++ __u8 bReserved;
++} __attribute__ ((packed));
++
++struct usb_generic_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++} __attribute__ ((packed));
++
++struct usb_generic_class_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++} __attribute__ ((packed));
++
++
++/*
++ * communications class descriptor structures
++ *
++ * c.f. CDC 5.2 Table 25c
++ */
++
++struct usb_class_function_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++} __attribute__ ((packed));
++
++struct usb_class_function_descriptor_generic {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bmCapabilities;
++} __attribute__ ((packed));
++
++struct usb_class_header_function_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x00
++ __u16 bcdCDC;
++} __attribute__ ((packed));
++
++struct usb_class_call_management_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x01
++ __u8 bmCapabilities;
++ __u8 bDataInterface;
++} __attribute__ ((packed));
++
++struct usb_class_abstract_control_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x02
++ __u8 bmCapabilities;
++} __attribute__ ((packed));
++
++struct usb_class_direct_line_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x03
++} __attribute__ ((packed));
++
++struct usb_class_telephone_ringer_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x04
++ __u8 bRingerVolSeps;
++ __u8 bNumRingerPatterns;
++} __attribute__ ((packed));
++
++struct usb_class_telephone_call_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x05
++ __u8 bmCapabilities;
++} __attribute__ ((packed));
++
++struct usb_class_union_function_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x06
++ __u8 bMasterInterface;
++ __u8 bSlaveInterface0[0];
++} __attribute__ ((packed));
++
++struct usb_class_country_selection_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x07
++ __u8 iCountryCodeRelDate;
++ __u16 wCountryCode0[0];
++} __attribute__ ((packed));
++
++
++struct usb_class_telephone_operational_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x08
++ __u8 bmCapabilities;
++} __attribute__ ((packed));
++
++
++struct usb_class_usb_terminal_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x09
++ __u8 bEntityId;
++ __u8 bInterfaceNo;
++ __u8 bOutInterfaceNo;
++ __u8 bmOptions;
++ __u8 bChild0[0];
++} __attribute__ ((packed));
++
++struct usb_class_network_channel_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x0a
++ __u8 bEntityId;
++ __u8 iName;
++ __u8 bChannelIndex;
++ __u8 bPhysicalInterface;
++} __attribute__ ((packed));
++
++struct usb_class_protocol_unit_function_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x0b
++ __u8 bEntityId;
++ __u8 bProtocol;
++ __u8 bChild0[0];
++} __attribute__ ((packed));
++
++struct usb_class_extension_unit_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x0c
++ __u8 bEntityId;
++ __u8 bExtensionCode;
++ __u8 iName;
++ __u8 bChild0[0];
++} __attribute__ ((packed));
++
++struct usb_class_multi_channel_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x0d
++ __u8 bmCapabilities;
++} __attribute__ ((packed));
++
++struct usb_class_capi_control_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x0e
++ __u8 bmCapabilities;
++} __attribute__ ((packed));
++
++struct usb_class_ethernet_networking_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x0f
++ __u8 iMACAddress;
++ __u32 bmEthernetStatistics;
++ __u16 wMaxSegmentSize;
++ __u16 wNumberMCFilters;
++ __u8 bNumberPowerFilters;
++} __attribute__ ((packed));
++
++struct usb_class_atm_networking_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x10
++ __u8 iEndSystermIdentifier;
++ __u8 bmDataCapabilities;
++ __u8 bmATMDeviceStatistics;
++ __u16 wType2MaxSegmentSize;
++ __u16 wType3MaxSegmentSize;
++ __u16 wMaxVC;
++} __attribute__ ((packed));
++
++
++struct usb_class_mdlm_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x12
++ __u16 bcdVersion;
++ __u8 bGUID[16];
++} __attribute__ ((packed));
++
++struct usb_class_mdlmd_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype; // 0x13
++ __u8 bGuidDescriptorType;
++ __u8 bDetailData[0];
++
++} __attribute__ ((packed));
++
++
++/*
++ * descriptor union structures
++ */
++
++struct usb_descriptor {
++ union {
++ struct usb_generic_descriptor generic;
++ struct usb_generic_class_descriptor generic_class;
++ struct usb_endpoint_descriptor endpoint;
++ struct usb_interface_descriptor interface;
++ struct usb_configuration_descriptor configuration;
++ struct usb_device_descriptor device;
++ struct usb_string_descriptor string;
++ } descriptor;
++
++} __attribute__ ((packed));
++
++struct usb_class_descriptor {
++ union {
++ struct usb_class_function_descriptor function;
++ struct usb_class_function_descriptor_generic generic;
++ struct usb_class_header_function_descriptor header_function;
++ struct usb_class_call_management_descriptor call_management;
++ struct usb_class_abstract_control_descriptor abstract_control;
++ struct usb_class_direct_line_descriptor direct_line;
++ struct usb_class_telephone_ringer_descriptor telephone_ringer;
++ struct usb_class_telephone_operational_descriptor telephone_operational;
++ struct usb_class_telephone_call_descriptor telephone_call;
++ struct usb_class_union_function_descriptor union_function;
++ struct usb_class_country_selection_descriptor country_selection;
++ struct usb_class_usb_terminal_descriptor usb_terminal;
++ struct usb_class_network_channel_descriptor network_channel;
++ struct usb_class_extension_unit_descriptor extension_unit;
++ struct usb_class_multi_channel_descriptor multi_channel;
++ struct usb_class_capi_control_descriptor capi_control;
++ struct usb_class_ethernet_networking_descriptor ethernet_networking;
++ struct usb_class_atm_networking_descriptor atm_networking;
++ struct usb_class_mdlm_descriptor mobile_direct;
++ struct usb_class_mdlmd_descriptor mobile_direct_detail;
++ } descriptor;
++
++} __attribute__ ((packed));
++
++
++/*
++ * Audio Status Word Format - c.f. Table 3.1
++ */
++#define AUDIO_STATUS_INTERRUPT_PENDING 1<<7
++#define AUDIO_STATUS_MEMORY_CONTENT_CHANGED 1<<6
++#define AUDIO_STATUS_ORIGINATOR_AUDIO_CONTROL_INTERFACE 0
++#define AUDIO_STATUS_ORIGINATOR_AUDIO_STREAMING_INTERFACE 1
++#define AUDIO_STATUS_ORIGINATOR_AUDIO_STREAMING_ENDPOINT 2
++#define AUDIO_STATUS_ORIGINATOR_AUDIOCONTROL_INTERFACE 0
++
++struct usb_audio_status_word {
++ __u8 bStatusType;
++ __u8 bOriginator;
++} __attribute__ ((packed));
++
++struct usb_audio_ac_interface_header_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u16 bcdADC;
++ __u16 wTotalLength;
++ __u8 binCollection;
++ __u8 bainterfaceNr[0];
++} __attribute__ ((packed));
++
++struct usb_audio_input_terminal_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bTerminalID;
++ __u16 wTerminalType;
++ __u8 bAssocTerminal;
++ __u8 bNrChannels;
++ __u16 wChannelConfig;
++ __u8 iChannelNames;
++ __u8 iTerminal;
++} __attribute__ ((packed));
++
++struct usb_audio_input_terminal_description {
++ struct usb_audio_input_terminal_descriptor *audio_input_terminal_descriptor;
++ __u16 wTerminalType;
++ __u16 wChannelConfig;
++ char * iChannelNames;
++ char * iTerminal;
++};
++
++struct usb_audio_output_terminal_descriptor {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bTerminalID;
++ __u16 wTerminalType;
++ __u8 bAssocTerminal;
++ __u8 bSourceID;
++ __u8 iTerminal;
++} __attribute__ ((packed));
++
++struct usb_audio_output_terminal_description {
++ struct usb_audio_output_terminal_descriptor *audio_output_terminal_descriptor;
++ __u16 wTerminalType;
++ char * iTerminal;
++};
++
++struct usb_audio_mixer_unit_descriptor_a {
++ __u8 bFunctionLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bUniteID;
++ __u8 bNrinPins;
++} __attribute__ ((packed));
++
++struct usb_audio_mixer_unit_descriptor_b {
++ __u8 baSourceID;
++ __u8 bNrChannels;
++ __u16 wChannelConfig;
++ __u8 iChannelNames;
++ __u8 bmControls;
++ __u8 iMixer;
++} __attribute__ ((packed));
++
++struct usb_audio_mixer_unit_description {
++ struct usb_audio_mixer_unit_descriptor *audio_mixer_unit_descriptor;
++ __u16 wChannelConfig;
++ char * iMixer;
++};
++
++
++struct usb_audio_as_general_interface_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bTerminalLink;
++ __u8 bDelay;
++ __u16 wFormatTag;
++} __attribute__ ((packed));
++
++struct usb_audio_as_general_interface_description {
++ struct usb_audio_as_general_interface_descriptor *audio_as_general_interface_descriptor;
++ __u16 wFormatTag;
++};
++
++struct usb_audio_as_format_type_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bFormatType;
++ __u8 bNrChannels;
++ __u8 bSubFrameSize;
++ __u8 bBitResolution;
++ __u8 bSamFreqType;
++ __u8 iSamFreq[3];
++} __attribute__ ((packed));
++
++struct usb_audio_as_format_type_description {
++ struct usb_audio_as_format_type_descriptor *audio_as_format_type_descriptor;
++ __u16 wFormatTag;
++};
++
++
++
++
++struct usb_audio_descriptor {
++ union {
++ struct usb_audio_ac_interface_header_descriptor header;
++ struct usb_audio_input_terminal_descriptor input;
++ struct usb_audio_output_terminal_descriptor output;
++ } descriptor;
++} __attribute__ ((packed));
++
++
++
++struct usb_ac_endpoint_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++ __u8 bEndpointAddress;
++ __u8 bmAttributes;
++ __u16 wMaxPacketSize;
++ __u8 bInterval;
++ __u8 bRefresh;
++ __u8 bSynchAddress;
++} __attribute__ ((packed));
++
++
++struct usb_as_iso_endpoint_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++ __u8 bDescriptorSubtype;
++ __u8 bmAttributes;
++ __u8 bLockDelayUnits;
++ __u16 wLockDelay;
++} __attribute__ ((packed));
++
++
+diff -Nru a/drivers/usbd/usbd-export.h b/drivers/usbd/usbd-export.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-export.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1 @@
++#define USBD_EXPORT_TAG "usbd-gpl-20040227-1420-usbd-amd-pb1x00-kit"
+diff -Nru a/drivers/usbd/usbd-fops.c b/drivers/usbd/usbd-fops.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-fops.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,589 @@
++/*
++ * usbd/usbd-fops.c - USB Function support
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/list.h>
++#include <asm/uaccess.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++
++#include <linux/smp_lock.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/string.h>
++
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-func.h"
++#include "usbd-bus.h"
++
++
++struct usb_string_descriptor **usb_strings;
++
++extern struct list_head usbd_function_drivers;
++extern struct usb_bus_instance *usbd_bus_instance;
++
++
++/* usbd_get_string - find and return a string descriptor
++ *
++ * Find an indexed string and return a pointer to a it.
++ */
++struct usb_string_descriptor *usbd_get_string (__u8 index)
++{
++ RETURN_NULL_IF (index >= usbd_maxstrings);
++ return usb_strings[index];
++}
++
++/* usbd_alloc_string - allocate a string descriptor and return index number
++ *
++ * Find an empty slot in index string array, create a corresponding descriptor
++ * and return the slot number.
++ */
++__u8 usbd_alloc_string (char *str)
++{
++ int i;
++ struct usb_string_descriptor *string;
++ __u8 bLength;
++ __u16 *wData;
++
++ RETURN_ZERO_IF(!str || !strlen (str));
++
++ //printk(KERN_INFO"%s: %s\n", __FUNCTION__, str);
++
++ // find an empty string descriptor slot
++ for (i = 1; i < usbd_maxstrings; i++) {
++
++ CONTINUE_IF (usb_strings[i] != NULL);
++
++ bLength = sizeof (struct usb_string_descriptor) + 2 * strlen (str);
++
++ RETURN_ZERO_IF(!(string = ckmalloc (bLength, GFP_KERNEL)));
++
++ string->bLength = bLength;
++ string->bDescriptorType = USB_DT_STRING;
++
++ for (wData = string->wData; *str;)
++ *wData++ = (__u16) (*str++);
++
++ // store in string index array
++ usb_strings[i] = string;
++ return i;
++ }
++ return 0;
++}
++
++
++/* usbd_dealloc_string - deallocate a string descriptor
++ *
++ * Find and remove an allocated string.
++ */
++void usbd_dealloc_string (__u8 index)
++{
++ struct usb_string_descriptor *string;
++
++ if ((index < usbd_maxstrings) && (string = usb_strings[index])) {
++ usb_strings[index] = NULL;
++ lkfree (string);
++ }
++}
++
++/* usbd_alloc_urb - allocate an URB appropriate for specified endpoint
++ *
++ * Allocate an urb structure. The usb device urb structure is used to
++ * contain all data associated with a transfer, including a setup packet for
++ * control transfers.
++ */
++struct urb *usbd_alloc_urb (struct usb_function_instance *function, int endpoint_index,
++ int length, int (*callback) (struct urb *, int))
++{
++ struct urb *urb = NULL;
++ struct usb_endpoint_map *endpoint_map;
++ struct usb_endpoint_instance *endpoint;
++ unsigned long flags;
++
++ //printk(KERN_INFO"%s: %s\n", __FUNCTION__, function->function_driver->name);
++ RETURN_NULL_IF(!function);
++ RETURN_NULL_IF(!(endpoint_map = function->endpoint_map_array));
++ RETURN_NULL_IF(!(endpoint = endpoint_map[endpoint_index].endpoint));
++
++ local_irq_save(flags);
++ THROW_IF (!(urb = ckmalloc (sizeof (struct urb), GFP_ATOMIC)), error);
++ urb->endpoint = endpoint;
++ urb->bus = function->bus;
++ urb->function_instance = function;
++ urb->link.prev = urb->link.next = &urb->link;
++ urb->callback = callback;
++ urb->buffer_length = urb->actual_length = 0;
++
++ if (length) {
++ urb->request_length = length;
++
++ /* For receive we always overallocate to ensure that receiving another
++ * full sized packet when we are only expecting a short packet will
++ * not overflow the buffer
++ */
++ if (!endpoint->bEndpointAddress || endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
++ length = ((length / endpoint->wMaxPacketSize) + 1) * endpoint->wMaxPacketSize;
++ }
++ urb->buffer_length = length;
++
++ if (urb->endpoint && urb->endpoint->bEndpointAddress && urb->function_instance &&
++ urb->function_instance->function_driver->fops->alloc_urb_data)
++ {
++ THROW_IF(urb->function_instance->function_driver->fops->alloc_urb_data (urb, length), error);
++ }
++ else {
++ THROW_IF(!(urb->buffer = ckmalloc (length, GFP_ATOMIC)), error);
++ }
++ }
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: dealloc %p\n", __FUNCTION__, urb);
++ usbd_dealloc_urb(urb);
++ urb = NULL;
++ }
++ local_irq_restore(flags);
++ //printk(KERN_INFO"%s: finis %p\n", __FUNCTION__, urb);
++ return urb;
++}
++
++struct urb *usbd_alloc_urb_ep0 (struct usb_function_instance *function, int length, int (*callback) (struct urb *, int))
++{
++ return usbd_alloc_urb(function->bus->ep0, 0, length, callback);
++}
++
++/* usbd_dealloc_urb - deallocate an URB and associated buffer
++ *
++ * Deallocate an urb structure and associated data.
++ */
++void usbd_dealloc_urb (struct urb *urb)
++{
++ RETURN_IF (!urb);
++ if (urb->buffer)
++ (urb->function_instance && urb->function_instance->function_driver->fops->dealloc_urb_data) ?
++ urb->function_instance->function_driver->fops->dealloc_urb_data : lkfree (urb->buffer);
++ lkfree (urb);
++}
++
++/* usbd_urb_callback - tell function that an urb has been transmitted.
++ *
++ * Must be called from an interrupt or with interrupts disabled.
++ *
++ * Used by a USB Bus driver to pass a sent urb back to the function
++ * driver via the endpoints done queue.
++ */
++void usbd_urb_callback (struct urb *urb, int rc)
++{
++ RETURN_IF (!urb);
++ if (!urb->callback || urb->callback(urb,rc))
++ usbd_dealloc_urb(urb);
++}
++
++
++/* usbd_recv_setup_irq - process a received urb
++ *
++ * Used by a USB Bus interface driver to pass received data in a URB to the
++ * appropriate USB Function driver.
++ */
++int usbd_recv_setup_irq (struct usb_function_instance *function, struct usb_device_request *request)
++{
++ return function->function_driver->fops->recv_setup_irq(request);
++}
++
++void *usbd_function_get_privdata(struct usb_function_instance *function)
++{
++ return(function->privdata);
++}
++
++void usbd_function_set_privdata(struct usb_function_instance *function, void *privdata)
++{
++ function->privdata = privdata;
++}
++
++int usbd_endpoint_wMaxPacketSize(struct usb_function_instance *function, int endpoint_index, int hs)
++{
++ struct usb_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return le16_to_cpu(endpoint_map[endpoint_index].wMaxPacketSize[hs]);
++}
++
++int usbd_endpoint_bEndpointAddress(struct usb_function_instance *function, int endpoint_index, int hs)
++{
++ struct usb_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return endpoint_map[endpoint_index].bEndpointAddress[hs];
++}
++
++int usbd_endpoint_transferSize(struct usb_function_instance *function, int endpoint_index, int hs)
++{
++ struct usb_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return endpoint_map[endpoint_index].transferSize[hs];
++}
++
++void usbd_endpoint_update(struct usb_function_instance *function, int endpoint_index,
++ struct usb_endpoint_descriptor *endpoint, int hs)
++{
++ endpoint->bEndpointAddress = usbd_endpoint_bEndpointAddress(function, endpoint_index, hs);
++ endpoint->wMaxPacketSize = usbd_endpoint_wMaxPacketSize(function, endpoint_index, hs);
++}
++
++int usbd_endpoint_interface(struct usb_function_instance *function, int endpoint_index)
++{
++ struct usb_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return endpoint_map[endpoint_index].interface;
++}
++
++int usbd_interface_AltSetting(struct usb_function_instance *function, int interface_index)
++{
++ // XXX TODO - per function modifications for composite devices
++ return function->bus->alternates[interface_index];
++}
++
++int usbd_ConfigurationValue(struct usb_function_instance *function)
++{
++ // XXX TODO - per function modifications for composite devices
++ return function->bus->ConfigurationValue;
++}
++
++int usbd_high_speed(struct usb_function_instance *function)
++{
++ // XXX TODO - per function modifications for composite devices
++ return function->bus->HighSpeedFlag;
++}
++
++/* usb-device USB FUNCTION generic functions ************************************************* */
++
++/* alloc_function_alternates - allocate alternate instance array
++ *
++ * Return a pointer to an array of alternate instances. Each instance contains a pointer
++ * to a filled in alternate descriptor and a pointer to the endpoint descriptor array.
++ *
++ * Returning NULL will cause the caller to cleanup all previously allocated memory.
++ */
++static struct usb_alternate_instance *alloc_function_alternates (int bInterfaceNumber,
++ struct usb_interface_description *interface_description,
++ int alternates, struct usb_alternate_description *alternate_description_array)
++{
++ int i;
++ struct usb_alternate_instance *alternate_instance_array;
++
++ // allocate array of alternate instances
++ RETURN_NULL_IF(!(alternate_instance_array = ckmalloc (sizeof (struct usb_alternate_instance) * alternates, GFP_KERNEL)));
++
++ // iterate across the alternate descriptions
++ for (i = 0; i < alternates; i++) {
++
++ struct usb_alternate_description *alternate_description = alternate_description_array + i;
++ struct usb_alternate_instance *alternate_instance = alternate_instance_array + i;
++ struct usb_interface_descriptor *interface_descriptor;
++
++ interface_descriptor = alternate_description->interface_descriptor;
++ if (interface_descriptor->bInterfaceNumber != bInterfaceNumber) {
++ printk(KERN_INFO"%s: bInterfaceNumber mis-match: %d should be %d\n", __FUNCTION__,
++ interface_descriptor->bInterfaceNumber, bInterfaceNumber);
++ lkfree(alternate_instance_array);
++ return NULL;
++ }
++
++ interface_descriptor->bNumEndpoints = alternate_description->endpoints;
++ interface_descriptor->iInterface = usbd_alloc_string (alternate_description->iInterface );
++
++ alternate_instance->class_list = alternate_description->class_list;
++ alternate_instance->classes = alternate_description->classes;
++ alternate_instance->endpoint_list = alternate_description->endpoint_list;
++ alternate_instance->endpoint_indexes = alternate_description->endpoint_indexes;
++
++ // save number of alternates, classes and endpoints for this alternate
++ alternate_instance->endpoints = alternate_description->endpoints;
++ alternate_instance->interface_descriptor = interface_descriptor;
++ }
++ return alternate_instance_array;
++}
++
++/* alloc_function_interfaces - allocate interface instance array
++ *
++ * Return a pointer to an array of interface instances. Each instance contains a pointer
++ * to a filled in interface descriptor and a pointer to the endpoint descriptor array.
++ *
++ * Returning NULL will cause the caller to cleanup all previously allocated memory.
++ */
++static struct usb_interface_instance *alloc_function_interfaces (int bNumInterfaces,
++ struct usb_interface_description *interface_description_array)
++{
++ int interface;
++ struct usb_interface_instance *interface_instance_array;
++
++ // allocate array of interface instances
++ RETURN_NULL_IF(!(interface_instance_array =
++ ckmalloc (sizeof (struct usb_interface_instance) * bNumInterfaces, GFP_KERNEL)));
++
++ // iterate across the interface descriptions
++ for (interface = 0; interface < bNumInterfaces; interface++) {
++
++ struct usb_interface_description *interface_description = interface_description_array + interface;
++ struct usb_interface_instance *interface_instance = interface_instance_array + interface;
++
++ interface_instance->alternates_instance_array =
++ alloc_function_alternates (interface, interface_description,
++ interface_description->alternates, interface_description->alternate_list);
++ interface_instance->alternates = interface_description->alternates;
++ }
++ return interface_instance_array;
++}
++
++
++/* alloc_function_configurations - allocate configuration instance array
++ *
++ * Return a pointer to an array of configuration instances. Each instance contains a pointer
++ * to a filled in configuration descriptor and a pointer to the interface instances array.
++ *
++ * Returning NULL will cause the caller to cleanup all previously allocated memory.
++ */
++static struct usb_configuration_instance *alloc_function_configurations (int bNumConfigurations,
++ struct usb_configuration_description *configuration_description_array)
++{
++ int i;
++ struct usb_configuration_instance *configuration_instance_array;
++
++ // allocate array
++ RETURN_NULL_IF(!(configuration_instance_array =
++ ckmalloc (sizeof (struct usb_configuration_instance) * bNumConfigurations, GFP_KERNEL)));
++ // fill in array
++ for (i = 0; i < bNumConfigurations; i++) {
++ int j;
++ int length;
++
++ struct usb_configuration_description *configuration_description = configuration_description_array + i;
++ struct usb_configuration_descriptor *configuration_descriptor;
++
++ configuration_descriptor = configuration_description->configuration_descriptor;
++
++ // setup fields in configuration descriptor
++ // XXX c.f. 9.4.7 zero is default, so config MUST BE 1 to n, not 0 to n-1
++ // XXX N.B. the configuration itself is fetched 0 to n-1.
++
++ configuration_descriptor->bConfigurationValue = i + 1;
++ configuration_descriptor->wTotalLength = 0;
++ configuration_descriptor->bNumInterfaces = configuration_description->bNumInterfaces;
++ configuration_descriptor->iConfiguration = usbd_alloc_string (configuration_description->iConfiguration);
++
++ // save the configuration descriptor in the configuration instance array
++ configuration_instance_array[i].configuration_descriptor = configuration_descriptor;
++
++ RETURN_NULL_IF (!(configuration_instance_array[i].interface_instance_array =
++ alloc_function_interfaces (configuration_description->bNumInterfaces,
++ configuration_description->interface_list)));
++
++ length = sizeof(struct usb_configuration_descriptor);
++
++ for (j = 0; j < configuration_descriptor->bNumInterfaces; j++) {
++
++ int alternate;
++ struct usb_interface_instance *interface_instance =
++ configuration_instance_array[i].interface_instance_array + j;
++
++ //printk(KERN_INFO"%s: len: %02x:%02d configuration\n", __FUNCTION__, length, length);
++ for (alternate = 0; alternate < interface_instance->alternates; alternate++) {
++ int class;
++ int endpoint;
++ struct usb_alternate_instance *alternate_instance =
++ interface_instance->alternates_instance_array + alternate;
++
++ length += sizeof (struct usb_interface_descriptor);
++
++ //printk(KERN_INFO"%s: len: %02x:%02d interface\n", __FUNCTION__, length, length);
++ for (class = 0; class < alternate_instance->classes; class++) {
++ struct usb_generic_class_descriptor * class_descriptor =
++ *(alternate_instance->class_list + class);
++ length += class_descriptor->bLength;
++ //printk(KERN_INFO"%s: len: %02x:%02d class\n", __FUNCTION__, length, length);
++ }
++
++ for (endpoint = 0; endpoint < alternate_instance->endpoints; endpoint++) {
++ struct usb_endpoint_descriptor * endpoint_descriptor =
++ *(alternate_instance->endpoint_list + endpoint);
++ length += endpoint_descriptor->bLength;
++ //printk(KERN_INFO"%s: len: %02x:%02d endpoint\n", __FUNCTION__, length, length);
++ }
++ }
++ }
++ configuration_descriptor->wTotalLength = cpu_to_le16 (length);
++ configuration_instance_array[i].bNumInterfaces = configuration_description->bNumInterfaces;
++ //printk(KERN_INFO"%s: configuration_instance_array[%d]: %p\n", __FUNCTION__, i,
++ // &configuration_instance_array[i]);
++ }
++ return configuration_instance_array;
++}
++
++
++void usbd_func_event_irq(struct usb_bus_instance *bus, struct usb_function_instance *function,
++ usb_device_event_t event , int data)
++{
++ function->function_driver->fops->event_irq(function, event, data);
++}
++
++
++/* usbd_register_function - register a usb function driver
++ *
++ * Used by a USB Function driver to register itself with the usb device layer.
++ *
++ * It will create a usb_function_instance structure.
++ *
++ * The user friendly configuration/interface/endpoint descriptions are compiled into
++ * the equivalent ready to use descriptor records.
++ *
++ * All function drivers must register before any bus interface drivers.
++ *
++ */
++int usbd_register_function (struct usb_function_driver *function_driver)
++{
++ MOD_INC_USE_COUNT;
++ list_add_tail (&function_driver->drivers, &usbd_function_drivers);
++ return 0;
++}
++
++
++/* usbd_deregister_function - called by a USB FUNCTION driver to deregister itself
++ *
++ * Called by a USB Function driver De-register a usb function driver.
++ */
++void usbd_deregister_function (struct usb_function_driver *function_driver)
++{
++ list_del (&function_driver->drivers);
++ MOD_DEC_USE_COUNT;
++}
++
++
++int usbd_function_enable (struct usb_bus_instance *bus, struct usb_function_instance *function)
++{
++ struct usb_function_driver *function_driver = function->function_driver;
++ struct usb_device_description *device_description;
++ struct usb_device_descriptor *device_descriptor;
++ int rc = 0;
++
++ function->bus = bus;
++
++ RETURN_EINVAL_IF(function_driver->fops->function_enable (function));
++ RETURN_ZERO_IF(!(device_description = function_driver->device_description));
++ RETURN_ZERO_IF(!(device_descriptor = device_description->device_descriptor));
++
++ device_descriptor->bMaxPacketSize0 = bus->driver->maxpacketsize;
++ device_descriptor->iManufacturer = usbd_alloc_string (device_description->iManufacturer);
++ device_descriptor->iProduct = usbd_alloc_string (device_description->iProduct);
++
++ if (bus->serial_number_str && strlen (bus->serial_number_str))
++ device_descriptor->iSerialNumber = usbd_alloc_string (bus->serial_number_str);
++ else
++ device_descriptor->iSerialNumber = usbd_alloc_string (device_description->iSerialNumber);
++
++ device_descriptor->bNumConfigurations = function_driver->bNumConfigurations;
++ device_descriptor->idVendor = function_driver->idVendor;
++ device_descriptor->idProduct = function_driver->idProduct;
++ device_descriptor->bcdDevice = function_driver->bcdDevice;
++
++ /* call alloc_function_configurations() to allocate the configuration descriptor array
++ */
++ RETURN_EINVAL_IF (!(function_driver->configuration_instance_array =
++ alloc_function_configurations (function_driver->bNumConfigurations,
++ function_driver->configuration_description)));
++ function_driver->device_descriptor = device_descriptor;
++ function_driver->device_qualifier_descriptor = device_description->device_qualifier_descriptor;
++ return rc;
++}
++
++
++void usbd_function_disable (struct usb_function_instance *function)
++{
++ int configuration;
++ struct usb_function_driver *function_driver = function->function_driver;
++ struct usb_configuration_instance *configuration_instance_array = function_driver->configuration_instance_array;
++
++ function->function_driver->fops->function_disable (function);
++
++ RETURN_IF(!function_driver->configuration_instance_array);
++
++ // iterate across the descriptors list and de-allocate all structures
++ if (function_driver->configuration_instance_array) {
++ for (configuration = 0; configuration < function_driver->bNumConfigurations; configuration++) {
++ int interface;
++ struct usb_configuration_instance *configuration_instance = configuration_instance_array + configuration;
++
++ for (interface = 0; interface < configuration_instance->bNumInterfaces; interface++) {
++
++ //int alternate;
++ struct usb_interface_instance *interface_instance =
++ configuration_instance->interface_instance_array + interface;
++
++ lkfree (interface_instance->alternates_instance_array);
++ }
++ lkfree (configuration_instance->interface_instance_array);
++ //usbd_dealloc_descriptor_strings( (struct usb_descriptor *)
++ // configuration_instance_array[configuration].configuration_descriptor);
++ }
++ }
++
++ //usbd_dealloc_descriptor_strings ((struct usb_descriptor *) function_driver->device_descriptor);
++ lkfree (configuration_instance_array);
++
++ function->bus = NULL;
++}
++
++EXPORT_SYMBOL(usbd_register_function );
++EXPORT_SYMBOL(usbd_deregister_function);
++EXPORT_SYMBOL(usbd_alloc_string);
++EXPORT_SYMBOL(usbd_dealloc_string);
++EXPORT_SYMBOL(usbd_get_string);
++EXPORT_SYMBOL(usbd_alloc_urb);
++EXPORT_SYMBOL(usbd_alloc_urb_ep0);
++EXPORT_SYMBOL(usbd_dealloc_urb);
++EXPORT_SYMBOL(usbd_recv_setup_irq);
++EXPORT_SYMBOL(usbd_urb_callback);
++EXPORT_SYMBOL(usbd_endpoint_halted);
++EXPORT_SYMBOL(usbd_device_feature);
++EXPORT_SYMBOL(usbd_function_get_privdata);
++EXPORT_SYMBOL(usbd_function_set_privdata);
++
++EXPORT_SYMBOL(usbd_endpoint_wMaxPacketSize);
++EXPORT_SYMBOL(usbd_endpoint_bEndpointAddress);
++EXPORT_SYMBOL(usbd_endpoint_interface);
++EXPORT_SYMBOL(usbd_endpoint_transferSize);
++EXPORT_SYMBOL(usbd_interface_AltSetting);
++EXPORT_SYMBOL(usbd_ConfigurationValue);
++EXPORT_SYMBOL(usbd_high_speed);
++EXPORT_SYMBOL(usbd_endpoint_update);
+diff -Nru a/drivers/usbd/usbd-func.h b/drivers/usbd/usbd-func.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-func.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,256 @@
++/*
++ * usbd/usbd-func.h - USB Device Function Driver Interface
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++/*
++ * This file contains the USB Function Driver Interface definitions.
++ *
++ * This is the interface between the bottom of the USB Function drivers and
++ * the top of the USB Core and is comprised of:
++ *
++ * o public functions exported by the USB Core layer
++ *
++ * o structures and functions passed by the Bus Interface Driver to the
++ * USB Core layer
++ *
++ *
++ * USB Function Drivers are structured such that the upper edge implements
++ * some specific function (network, serial, mass storage etc) and the lower
++ * edge interfaces to the USB Device Core for USB services.
++ *
++ */
++
++/*
++ * USB Function Driver structures
++ *
++ * Descriptors:
++ * struct usb_endpoint_description
++ * struct usb_interface_description
++ * struct usb_configuration_description
++ *
++ * Driver description:
++ * struct usb_function_driver
++ * struct usb_function_operations
++ *
++ */
++
++struct usb_function_operations {
++ int (*function_enable) (struct usb_function_instance *);
++ void (*function_disable) (struct usb_function_instance *);
++ void (*event_irq) (struct usb_function_instance *, usb_device_event_t, int);
++ int (*recv_setup_irq) (struct usb_device_request *);
++ int (*alloc_urb_data) (struct urb *, int);
++ void (*dealloc_urb_data) (struct urb *);
++};
++
++
++/*
++ * function driver definitions
++ */
++struct usb_alternate_instance {
++ struct usb_interface_descriptor *interface_descriptor;
++ int classes;
++ struct usb_generic_class_descriptor **class_list;
++ int endpoints;
++ struct usb_endpoint_descriptor **endpoint_list;
++ u8 *endpoint_indexes;
++};
++
++
++/*
++ * usb device description structures
++ */
++
++struct usb_alternate_description {
++ struct usb_interface_descriptor *interface_descriptor;
++ char *iInterface;
++
++ // list of CDC class descriptions for this alternate interface
++ u8 classes;
++ struct usb_generic_class_descriptor **class_list;
++
++ // list of endpoint descriptions for this alternate interface
++ u8 endpoints;
++ struct usb_endpoint_descriptor **endpoint_list;
++
++ // list of indexes into endpoint request map for each endpoint descriptor
++ u8 *endpoint_indexes;
++};
++
++struct usb_interface_description {
++ // list of alternate interface descriptions for this interface
++ u8 alternates;
++ struct usb_alternate_description *alternate_list;
++};
++
++struct usb_configuration_description {
++ struct usb_configuration_descriptor *configuration_descriptor;
++ char *iConfiguration;
++ // list of interface descriptons for this configuration
++ u8 bNumInterfaces;
++ struct usb_interface_description *interface_list;
++ int configuration_type;
++};
++
++struct usb_device_description {
++ struct usb_device_descriptor *device_descriptor;
++ struct usb_device_qualifier_descriptor *device_qualifier_descriptor;
++ char *iManufacturer;
++ char *iProduct;
++ char *iSerialNumber;
++ u8 endpointsRequested;
++ struct usb_endpoint_request *requestedEndpoints;
++ struct usb_function_endpoint_config *endpointConfig;
++};
++
++
++struct usb_interface_instance {
++ u8 alternates;
++ struct usb_alternate_instance *alternates_instance_array;
++};
++
++struct usb_configuration_instance {
++ int bNumInterfaces;
++ struct usb_configuration_descriptor *configuration_descriptor;
++ struct usb_interface_instance *interface_instance_array;
++ struct usb_function_driver *function_driver;
++};
++
++
++extern struct usb_string_descriptor **usb_strings;
++__u8 usbd_alloc_string (char *);
++void usbd_dealloc_string (__u8 );
++void usbd_dealloc_descriptor_strings (struct usb_descriptor *);
++struct usb_string_descriptor *usbd_get_string (__u8);
++
++
++
++
++/* Function Driver data structure
++ *
++ * Function driver and its configuration descriptors.
++ *
++ * This is passed to the usb-device layer when registering. It contains all
++ * required information about the function driver for the usb-device layer
++ * to use the function drivers configuration data and to configure this
++ * function driver an active configuration.
++ *
++ * Note that each function driver registers itself on a speculative basis.
++ * Whether a function driver is actually configured will depend on the USB
++ * HOST selecting one of the function drivers configurations.
++ *
++ * This may be done multiple times WRT to either a single bus interface
++ * instance or WRT to multiple bus interface instances. In other words a
++ * multiple configurations may be selected for a specific bus interface. Or
++ * the same configuration may be selected for multiple bus interfaces.
++ *
++ */
++struct usb_function_driver {
++ const char *name;
++ struct usb_function_operations *fops; // functions
++
++ // device & configuration descriptions
++ struct usb_device_description *device_description;
++ struct usb_configuration_description *configuration_description;
++ int bNumConfigurations;
++
++ u16 idVendor;
++ u16 idProduct;
++ u16 bcdDevice;
++
++ // constructed descriptors
++ struct usb_device_descriptor *device_descriptor;
++ struct usb_device_qualifier_descriptor *device_qualifier_descriptor;
++ struct usb_configuration_instance *configuration_instance_array;
++
++ struct list_head drivers; // linked list
++};
++
++
++struct usb_function_instance;
++
++/* function driver registration
++ *
++ * Called by function drivers to register themselves when loaded
++ * or de-register when unloading.
++ */
++//int usbd_strings_init(void);
++int usbd_register_function (struct usb_function_driver *);
++void usbd_deregister_function (struct usb_function_driver *);
++
++/* Access to function privdata
++ */
++void *usbd_function_get_privdata(struct usb_function_instance *function);
++void usbd_function_set_privdata(struct usb_function_instance *function, void *privdata);
++/*
++ * Called to queue urb's for send or recv
++ */
++int usbd_send_urb (struct urb *urb);
++int usbd_start_recv (struct urb *);
++
++/*
++ * queury endpoint astatus
++ */
++int usbd_endpoint_halted (struct usb_function_instance *, int);
++int usbd_device_feature (struct usb_function_instance *, int, int);
++
++
++/*
++ * query bus state and status
++ */
++usb_device_state_t usbd_device_state(struct usb_function_instance *);
++usbd_bus_state_t usbd_bus_state(struct usb_function_instance *);
++usb_device_status_t usbd_bus_status(struct usb_function_instance *);
++
++
++/* urb allocation
++ *
++ * Used to allocate and de-allocate urb structures.
++ * usb_cancel_urb is used to cancel a previously submitted data urb for sending.
++ */
++struct urb *usbd_alloc_urb (struct usb_function_instance *, int, int length, int (*callback) (struct urb *, int));
++struct urb *usbd_alloc_urb_ep0 (struct usb_function_instance *, int length, int (*callback) (struct urb *, int));
++void usbd_dealloc_urb (struct urb *urb);
++int usbd_alloc_urb_data (struct urb *, int);
++int usbd_cancel_urb_irq (struct urb *);
++
++/* endpoint information
++ *
++ * Used by function drivers to get specific endpoint information
++ */
++int usbd_endpoint_wMaxPacketSize(struct usb_function_instance *, int, int);
++int usbd_endpoint_bEndpointAddress(struct usb_function_instance *, int, int);
++int usbd_endpoint_transferSize(struct usb_function_instance *, int, int);
++int usbd_endpoint_interface(struct usb_function_instance *, int);
++int usbd_interface_AltSetting(struct usb_function_instance *, int);
++int usbd_ConfigurationValue(struct usb_function_instance *);
++void usbd_endpoint_update(struct usb_function_instance *, int , struct usb_endpoint_descriptor *, int);
++int usbd_high_speed(struct usb_function_instance *);
++
+diff -Nru a/drivers/usbd/usbd-mem.h b/drivers/usbd/usbd-mem.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-mem.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,146 @@
++/*
++ * usbd/usbd-mem.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#ifndef MODULE
++#undef __init
++#define __init
++#undef __exit
++#define __exit
++#undef THIS_MODULE
++#define THIS_MODULE 0
++#endif
++
++#define USBD_MODULE_INFO(info) static const char __usbd_module_info[] = info " " USBD_BUILD " %D% %@%";
++
++
++#ifndef MIN
++#define MIN(a,b) ((a) < (b) ? (a) : (b))
++#endif
++#ifndef MAX
++#define MAX(a,b) ((a) > (b) ? (a) : (b))
++#endif
++#define CATCH(x) while(0) x:
++#define THROW(x) goto x
++#define THROW_IF(e, x) if (e) goto x;
++#define BREAK_IF(x) if (x) break;
++#define CONTINUE_IF(x) if (x) continue;
++#define RETURN_IF(x) if (x) return;
++#define RETURN_ZERO_IF(x) if (x) return 0;
++#define RETURN_EINVAL_IF(x) if (x) return -EINVAL;
++#define RETURN_EFAULT_IF(x) if (x) return -EFAULT;
++#define RETURN_ENOMEM_IF(x) if (x) return -ENOMEM;
++#define RETURN_EBUSY_IF(x) if (x) return -EBUSY;
++#define RETURN_NULL_IF(x) if (x) return NULL;
++#define unless(x) if(!(x))
++#define UNLESS(x) if(!(x))
++#define RETURN_UNLESS(x) UNLESS (x) return;
++#define RETURN_ZERO_UNLESS(x) UNLESS (x) return 0;
++#define CONTINUE_UNLESS(x) UNLESS (x) continue;
++
++
++#ifndef likely
++#define likely(x) x
++#endif
++
++#ifndef unlikely
++#define unlikely(x) x
++#endif
++
++#define ckmalloc(n,f) _ckmalloc(__FUNCTION__, __LINE__, n, f)
++#define lstrdup(str) _lstrdup(__FUNCTION__, __LINE__, str)
++#define lkfree(p) _lkfree(__FUNCTION__, __LINE__, p)
++
++#define MALLOC_TEST
++#undef MALLOC_DEBUG
++
++#ifdef MALLOC_TEST
++extern int usbd_mallocs;
++#endif
++
++
++static __inline__ void *_ckmalloc (char *func, int line, int n, int f)
++{
++ void *p;
++ if ((p = kmalloc (n, f)) == NULL) {
++ return NULL;
++ }
++ memset (p, 0, n);
++#ifdef MALLOC_TEST
++ ++usbd_mallocs;
++#endif
++#ifdef MALLOC_DEBUG
++ printk(KERN_INFO"%s: %p %s %d %d\n", __FUNCTION__, p, func, line, usbd_mallocs);
++#endif
++ return p;
++}
++
++static __inline__ char *_lstrdup (char *func, int line, char *str)
++{
++ int n;
++ char *s;
++ if (str && (n = strlen (str) + 1) && (s = kmalloc (n, GFP_ATOMIC))) {
++#ifdef MALLOC_TEST
++ ++usbd_mallocs;
++#endif
++#ifdef MALLOC_DEBUG
++ printk(KERN_INFO"%s: %p %s %d %d\n", __FUNCTION__, s, func, line, usbd_mallocs);
++#endif
++ return strcpy (s, str);
++ }
++ return NULL;
++}
++
++static __inline__ void _lkfree (char *func, int line, void *p)
++{
++ if (p) {
++#ifdef MALLOC_TEST
++ --usbd_mallocs;
++#endif
++#ifdef MALLOC_DEBUG
++ printk(KERN_INFO"%s: %p %s %d %d\n", __FUNCTION__, p, func, line, usbd_mallocs);
++#endif
++ kfree (p);
++#ifdef MALLOC_TEST
++ if (usbd_mallocs < 0) {
++ printk(KERN_INFO"%s: %p %s %d %d usbd_mallocs less zero!\n", __FUNCTION__, p, func, line, usbd_mallocs);
++ }
++#endif
++ }
++#ifdef MALLOC_DEBUG
++ else {
++ printk(KERN_INFO"%s: %s %d NULL\n", __FUNCTION__, func, line);
++ }
++#endif
++}
++
++
++
+diff -Nru a/drivers/usbd/usbd-procfs.c b/drivers/usbd/usbd-procfs.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd-procfs.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,337 @@
++/*
++ * usbd/usbd-procfs.c - USB Device Core Layer
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++EXPORT_NO_SYMBOLS;
++
++#include "usbd-export.h"
++#include "usbd-build.h"
++
++#ifdef MODULE
++MODULE_AUTHOR ("sl@lineo.com, tbr@lineo.com");
++MODULE_DESCRIPTION ("USB Device Core Support Procfs");
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("GPL");
++#endif
++
++#endif
++
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/proc_fs.h>
++#include <asm/uaccess.h>
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++
++#include <linux/smp_lock.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/string.h>
++
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-func.h"
++#include "usbd-bus.h"
++
++USBD_MODULE_INFO ("usbdprocfs 2.0-beta");
++
++#define MAX_INTERFACES 2
++
++extern struct list_head usbd_function_drivers;
++extern struct usb_bus_instance *usbd_bus_instance;
++
++
++#ifdef CONFIG_USBD_PROCFS
++/* Proc Filesystem *************************************************************************** */
++
++
++/* *
++ * dohex
++ *
++ */
++static void dohexdigit (char *cp, unsigned char val)
++{
++ if (val < 0xa) {
++ *cp = val + '0';
++ } else if ((val >= 0x0a) && (val <= 0x0f)) {
++ *cp = val - 0x0a + 'a';
++ }
++}
++
++/* *
++ * dohex
++ *
++ */
++static void dohexval (char *cp, unsigned char val)
++{
++ dohexdigit (cp++, val >> 4);
++ dohexdigit (cp++, val & 0xf);
++}
++
++/* *
++ * dump_descriptor
++ */
++static int dump_descriptor (char *buf, char *sp)
++{
++ int num = *sp;
++ int len = 0;
++
++ //printk(KERN_INFO"%s: %p %d %d %d\n", __FUNCTION__, buf, *buf, buf[0], num);
++
++ while (sp && num--) {
++ dohexval (buf, *sp++);
++ buf += 2;
++ *buf++ = ' ';
++ len += 3;
++ }
++ len++;
++ *buf = '\n';
++ return len;
++}
++
++/* dump_descriptors
++ */
++static int dump_config_descriptor(char *buf, char *sp)
++{
++ struct usb_configuration_descriptor *config = (struct usb_configuration_descriptor *) sp;
++
++ int wTotalLength = le16_to_cpu(config->wTotalLength);
++ int bConfigurationValue = config->bConfigurationValue;
++ int interface;
++ int class;
++ int endpoint;
++ int total;
++
++ interface = class = endpoint = 0;
++
++ for (total = 0; wTotalLength; ) {
++ //printk(KERN_INFO"%s: wTotalLength: %d total: %d bLength: %d\n",
++ // __FUNCTION__, wTotalLength, total, sp[0]);
++ switch (sp[1]) {
++ case USB_DESCRIPTOR_TYPE_CONFIGURATION:
++ interface = class = endpoint = 0;
++ total += sprintf(buf + total, "\nConfiguration descriptor [%d ] ",
++ bConfigurationValue);
++ break;
++ case USB_DESCRIPTOR_TYPE_INTERFACE:
++ class = 0;
++ total += sprintf(buf + total, "\nInterface descriptor [%d:%d:%d ] ",
++ bConfigurationValue, ++interface, class);
++ break;
++ case USB_DESCRIPTOR_TYPE_ENDPOINT:
++ class = endpoint = 0;
++ total += sprintf(buf + total, "Endpint descriptor [%d:%d:%d:%d] ",
++ bConfigurationValue, interface, class, ++endpoint);
++ break;
++ default:
++ endpoint = 0;
++ total += sprintf(buf + total, "Class descriptor [%d:%d:%d ] ",
++ bConfigurationValue, interface, ++class);
++ break;
++ }
++ total += dump_descriptor(buf + total, sp);
++ wTotalLength -= sp[0];
++ sp += sp[0];
++ }
++ total += sprintf(buf + total, "\n");
++ return total;
++}
++
++/* *
++ * usbd_device_proc_read - implement proc file system read.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Standard proc file system read function.
++ *
++ * We let upper layers iterate for us, *pos will indicate which device to return
++ * statistics for.
++ */
++static ssize_t usbd_device_proc_read_functions (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++
++ u8 config_descriptor[512];
++ int config_size;
++
++ //struct list_head *lhd;
++
++ // get a page, max 4095 bytes of data...
++ if (!(page = get_free_page (GFP_KERNEL))) {
++ return -ENOMEM;
++ }
++
++ len = 0;
++ index = (*pos)++;
++
++ if (index == 0) {
++ len += sprintf ((char *) page + len, "usb-device list\n");
++ }
++
++ //printk(KERN_INFO"%s: index: %d len: %d\n", __FUNCTION__, index, len);
++
++ if (usbd_bus_instance && usbd_bus_instance->function_instance) {
++ int configuration = index;
++ struct usb_function_instance *function_instance = usbd_bus_instance->function_instance;
++ struct usb_function_driver *function_driver = function_instance->function_driver;
++ struct usb_configuration_instance *configuration_instance_array = function_driver->configuration_instance_array;
++ if (configuration_instance_array) {
++
++ if (index == 0) {
++ len += sprintf ((char *) page + len, "\nDevice descriptor ");
++ len += dump_descriptor ((char *) page + len, (char *) function_driver->device_descriptor);
++#ifdef CONFIG_USBD_HIGH_SPEED
++ len += sprintf ((char *) page + len, "\nDevice Qualifier descriptor ");
++ len += dump_descriptor ((char *) page + len,
++ (char *) function_driver->device_qualifier_descriptor);
++#endif
++ }
++ if (configuration < function_driver->bNumConfigurations) {
++
++ if ((config_size = usbd_get_descriptor(usbd_bus_instance, config_descriptor,
++ sizeof(config_descriptor),
++ USB_DESCRIPTOR_TYPE_CONFIGURATION, 0)) > index) {
++ len += dump_config_descriptor((char *)page + len, config_descriptor );
++ }
++#ifdef CONFIG_USBD_HIGH_SPEED
++ if ((config_size = usbd_get_descriptor(usbd_bus_instance, config_descriptor,
++ sizeof(config_descriptor),
++ USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION, index)) > 0) {
++ len += dump_config_descriptor((char *)page + len, config_descriptor );
++ }
++
++#endif
++ }
++ else if (configuration == function_driver->bNumConfigurations) {
++ int i;
++ int k;
++ struct usb_string_descriptor *string_descriptor;
++
++ //len += sprintf ((char *) page + len, "\n\n");
++
++ if ((string_descriptor = usbd_get_string (0)) != NULL) {
++ len += sprintf ((char *) page + len, "String [%2d] ", 0);
++
++ for (k = 0; k < (string_descriptor->bLength / 2) - 1; k++) {
++ len += sprintf ((char *) page + len, "%02x %02x ",
++ string_descriptor->wData[k] >> 8,
++ string_descriptor->wData[k] & 0xff);
++ len++;
++ }
++ len += sprintf ((char *) page + len, "\n");
++ }
++
++ for (i = 1; i < usbd_maxstrings; i++) {
++
++ if ((string_descriptor = usbd_get_string (i)) != NULL) {
++
++ len += sprintf((char *)page+len, "String [%2d:%2d] ",
++ i, string_descriptor->bLength);
++
++ // bLength = sizeof(struct usb_string_descriptor) + 2*strlen(str)-2;
++
++ for (k = 0; k < (string_descriptor->bLength / 2) - 1; k++) {
++ *(char *) (page + len) = (char) string_descriptor->wData[k];
++ len++;
++ }
++ len += sprintf ((char *) page + len, "\n");
++ }
++ }
++ len += sprintf((char *)page + len, "\n--\n");
++ }
++ }
++ }
++
++ //printk(KERN_INFO"%s: len: %d count: %d\n", __FUNCTION__, len, count);
++
++ if (len > count) {
++ //printk(KERN_INFO"%s: len > count\n", __FUNCTION__);
++ //printk(KERN_INFO"%s", page);
++ len = -EINVAL;
++ }
++ else if ((len > 0) && copy_to_user (buf, (char *) page, len)) {
++ //printk(KERN_INFO"%s: EFAULT\n", __FUNCTION__);
++ len = -EFAULT;
++ }
++ else {
++ //printk(KERN_INFO"%s: OK\n", __FUNCTION__);
++ }
++ free_page (page);
++ return len;
++}
++
++static struct file_operations usbd_device_proc_operations_functions = {
++read:usbd_device_proc_read_functions,
++};
++
++#endif
++
++
++
++/* Module init ******************************************************************************* */
++
++
++static int usbd_procfs_init (void)
++{
++#ifdef CONFIG_USBD_PROCFS
++ {
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry ("usb-functions", 0, 0)) == NULL)
++ return -ENOMEM;
++ p->proc_fops = &usbd_device_proc_operations_functions;
++ }
++#endif
++ return 0;
++}
++
++static void usbd_procfs_exit (void)
++{
++#ifdef CONFIG_USBD_PROCFS
++ // remove proc filesystem entry
++ remove_proc_entry ("usb-functions", NULL);
++#endif
++}
++
++module_init (usbd_procfs_init);
++module_exit (usbd_procfs_exit);
++
+diff -Nru a/drivers/usbd/usbd.c b/drivers/usbd/usbd.c
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd.c Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,663 @@
++/*
++ * usbd/usbd.c - USB Device Core Layer
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
++ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ * See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along with this program; if
++ * not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++#include <linux/interrupt.h>
++#include <linux/init.h>
++#include <asm/uaccess.h>
++#include <linux/slab.h>
++#include <linux/proc_fs.h>
++#include <linux/ctype.h>
++#include <linux/string.h>
++#if defined(CONFIG_PM)
++#include <linux/pm.h>
++#endif
++
++#include "usbd-export.h"
++#include "usbd-build.h"
++#include "usbd-chap9.h"
++#include "usbd-mem.h"
++#include "usbd.h"
++#include "usbd-func.h"
++#include "usbd-bus.h"
++#include "usbd-admin.h"
++
++MODULE_AUTHOR ("sl@lineo.com, tbr@lineo.com");
++MODULE_DESCRIPTION ("USB Device Core Support");
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("GPL");
++#endif
++USBD_MODULE_INFO ("usbdcore 2.0-beta");
++
++int usbd_maxstrings = 20;
++extern int usbd_switch_init(void);
++LIST_HEAD (usbd_function_drivers); // list of all registered function modules
++struct usb_bus_instance *usbd_bus_instance;
++#ifdef MALLOC_TEST
++int usbd_mallocs;
++#endif
++
++/* ******************************************************************************************* */
++/*
++ * USBD Switch will make direct calls to the appropriate modinit/modexit and
++ * bus interface bi_modinit/bi_modexit functions to load and unload as appropriate.
++ *
++ *
++ * The following entry points are exported:
++ *
++ * int usbd_enable(void)
++ * int usbd_disable(char *name)
++ * int usbd_disconnect(char *name)
++ * int usbd_connect(char *name)
++ * int usbd_pm_on(char *name)
++ * int usbd_pm_off(char *name)
++ *
++ * int usbd_unload(void)
++ * int usbd_load(char *name)
++ * int usbd_unplug(char *name)
++ * int usbd_replug(char *name)
++ *
++ *
++ * If CONFIG_PROCFS is defined then the following commands can be given to /proc/usbd-switch:
++ *
++ * enable
++ * enable name
++ * disable
++ * disconnect
++ * connect
++ *
++ * serial_number
++ * debug
++ * nodebug
++ *
++ *
++ * There are four different styles of operations that can be used:
++ *
++ * 1. switch - change or configure the device function by sending any
++ * one of a number of commands to the switch interface [1] of
++ * usbd-switch:
++ *
++ * - echo "serial_number xxxxx" > /proc/usbd-switch
++ * - echo "enable network_fd" > /proc/usbd-switch
++ * - echo "disconnect" > /proc/usbd-switch
++ * - echo "connect" > /proc/usbd-switch
++ * - echo "disable" > /proc/usbd-switch
++ *
++ * serial_number - set the serial number string
++ * enable function - set current function and enable function and bus interface
++ * enable - enable current function and bus interface
++ * disable - disable bus interface and current function
++ * connect - enable current function and bus interface and connect pullup resistor
++ * disconnect - unload bus interface, current function and reset current function,
++ * and disconnect pullup resistor
++ *
++ * 2. simple power management
++ *
++ * - EXPORT_SYMBOL(usbd_enable);
++ * - EXPORT_SYMBOL(usbd_disable);
++ * - EXPORT_SYMBOL(usbd_disconnect);
++ * - EXPORT_SYMBOL(usbd_connect);
++ * - EXPORT_SYMBOL(usbd_pm_on);
++ * - EXPORT_SYMBOL(usbd_pm_off);
++ *
++ * Deprecated:
++ *
++ * - EXPORT_SYMBOL(usbd_load);
++ * - EXPORT_SYMBOL(usbd_unload);
++ * - EXPORT_SYMBOL(usbd_unplug);
++ * - EXPORT_SYMBOL(usbd_replug);
++ *
++ * usbd_enable() - load function and bus interface
++ * usbd_disable() - unload bus interface and function
++ *
++ * usbd_connect() - connect
++ * usbd_disconnect() - disconnect
++ *
++ * usbd_pm_on() - connect
++ * usbd_pm_off() - disconnect
++ *
++ * usbd_load() - load function and bus interface
++ * usbd_unload() - unload bus interface and function
++ * usbd_unplug() - disconnect
++ * usbd_replug() - connect
++ *
++ * 3. official power management CONFIG_PM [not tested yet]
++ *
++ * Perform unplug and plug functions appropriate for CONFIG_PM actions.
++ *
++ *
++ * N.B.
++ *
++ * [1] The switch interface is only available when the USB device stack
++ * and usbd-switch are compiled into the kernel. It is not available
++ * when the USB device stack consists of loadable modules.
++ *
++ * [2] Cable detection requires implementation of architecture specific
++ * code that knows about the appropriate interrupt, GPIO pins etc.
++ *
++ */
++
++
++extern struct list_head usbd_function_drivers;
++
++
++/*
++ * This is a table of function drivers that are compiled into the kernel.
++ */
++
++#define MAX_FUNC_NAME_LEN 64
++char current_function[MAX_FUNC_NAME_LEN+1];
++int switch_debug = 0;
++
++char *usbd_load_arg;
++
++int switch_exiting;
++struct tq_struct enable_bh;
++struct tq_struct disable_bh;
++
++
++
++/* ******************************************************************************************* */
++
++static DECLARE_MUTEX(usbd_sem); // protect against multiple administrative actions overlapping
++
++extern struct usb_bus_instance *usbd_bus_instance;
++
++char *usbd_admin_names[] = {
++ "enable", "disable", "connect", "disconnect", "pm_off", "pm_on", "serial_number",
++};
++
++char *usbd_admin_aliases[] = {
++ "load", "unload", "replug", "unplug", "pm_off", "pm_on", "serial_number_str",
++};
++
++
++/* usbd_admin -
++ */
++static int usbd_admin(usbd_admin_t usbd_admin_ndx, char *arg)
++{
++
++ printk(KERN_INFO"%s: %s current: %s arg: %s\n", __FUNCTION__,
++ usbd_admin_names[usbd_admin_ndx],
++ current_function[0] ? current_function : "(EMPTY)",
++ (arg && arg[0]) ? arg : "(EMPTY)");
++
++ RETURN_EINVAL_IF(in_interrupt() || down_interruptible(&usbd_sem));
++
++ /*
++ *
++ */
++ if (usbd_admin_ndx == usbd_admin_enable && (NULL == arg || 0 == *arg)) {
++ // s/enable/enable current_function/
++ arg = current_function;
++ }
++
++ THROW_IF(!usbd_bus_instance, error);
++
++ THROW_IF (!usbd_bus_instance->admin[usbd_admin_ndx] ||
++ usbd_bus_instance->admin[usbd_admin_ndx](usbd_bus_instance, arg), error);
++
++ if (usbd_admin_ndx == usbd_admin_enable && NULL != arg && arg != current_function) {
++ // update current_function
++ strncpy(current_function,arg,MAX_FUNC_NAME_LEN);
++ }
++
++ up(&usbd_sem);
++ return 0;
++
++ CATCH(error) {
++ printk(KERN_INFO"%s: %d error\n", __FUNCTION__, usbd_admin_ndx);
++
++ up(&usbd_sem);
++ return -ENODEV;
++ }
++}
++
++
++/* usbd_enable -
++ */
++int usbd_enable(char *arg)
++{
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++ RETURN_ZERO_IF(switch_exiting);
++ return usbd_admin(usbd_admin_enable, arg);
++}
++
++void usbd_enable_bh(void *arg)
++{
++ usbd_admin(usbd_admin_enable, (char *)arg);
++}
++
++int usbd_enable_irq(char *arg)
++{
++ RETURN_ZERO_IF(enable_bh.sync || switch_exiting);
++ schedule_task(&enable_bh);
++ return 0;
++}
++
++
++/* usbd_disable -
++ */
++int usbd_disable(char *arg)
++{
++ RETURN_ZERO_IF(switch_exiting);
++ return usbd_admin(usbd_admin_disable, arg);
++}
++
++void usbd_disable_bh(void *arg)
++{
++ usbd_admin(usbd_admin_disable, (char *)arg);
++}
++
++int usbd_disable_irq(char *arg)
++{
++ RETURN_ZERO_IF(disable_bh.sync || switch_exiting);
++ schedule_task(&disable_bh);
++ return 0;
++}
++
++/* usbd_load -
++ */
++int usbd_load(char *arg)
++{
++ if (arg && strlen(arg)) {
++ if ( usbd_load_arg)
++ lkfree(usbd_load_arg);
++ usbd_load_arg = lstrdup(arg);
++ }
++ return usbd_admin(usbd_admin_enable, arg);
++}
++
++/* usbd_unload -
++ */
++int usbd_unload(char *arg)
++{
++ return usbd_admin(usbd_admin_disable, arg);
++}
++
++
++/* usbd_connect -
++ */
++int usbd_connect(char *arg)
++{
++ return usbd_admin(usbd_admin_connect, arg);
++}
++
++/* usbd_disconnect -
++ */
++int usbd_disconnect(char *arg)
++{
++ return usbd_admin(usbd_admin_disconnect, arg);
++}
++
++
++/* usbd_replug -
++ */
++int usbd_replug(char *arg)
++{
++ return usbd_admin(usbd_admin_connect, arg);
++}
++
++/* usbd_unplug -
++ */
++int usbd_unplug(char *arg)
++{
++ return usbd_admin(usbd_admin_disconnect, arg);
++}
++
++
++
++/* usbd_pm_off -
++ */
++int usbd_pm_off(char *arg)
++{
++ return usbd_admin(usbd_admin_pm_off, arg);
++}
++
++/* usbd_pm_on -
++ */
++int usbd_pm_on(char *arg)
++{
++ return usbd_admin(usbd_admin_pm_on, arg);
++}
++
++
++
++
++/* ******************************************************************************************* */
++#ifdef CONFIG_USBD_PROCFS
++
++static int usbd_admin_procfs(char *arg)
++{
++ usbd_admin_t admin;
++ RETURN_EINVAL_IF(!arg || !strlen(arg));
++
++ for (admin = usbd_admin_enable; admin <= usbd_admin_serial_number; admin++) {
++ char *cp = usbd_admin_names[admin];
++ int len = strlen(cp);
++ if (!strncmp(arg, cp, len)) {
++ cp = arg + len;
++ while (cp && ((*cp == ' ') || (*cp == '\t'))) cp++;
++ return usbd_admin(admin, cp);
++ }
++ }
++
++ for (admin = usbd_admin_enable; admin <= usbd_admin_serial_number; admin++) {
++ char *cp = usbd_admin_aliases[admin];
++ int len = strlen(cp);
++ if (!strncmp(arg, cp, len)) {
++ cp = arg + len;
++ while (cp && ((*cp == ' ') || (*cp == '\t'))) cp++;
++ return usbd_admin(admin, cp);
++ }
++ }
++
++ return -EINVAL;
++}
++
++/* usbd_proc_switch_write - handle a user switch request
++ */
++static ssize_t usbd_proc_switch_write (struct file *file, const char *buf, size_t count, loff_t * pos)
++{
++
++ char command[MAX_FUNC_NAME_LEN+1];
++ size_t n = count;
++ size_t l;
++ char c;
++
++ command[0] = 0;
++ if (n > 0) {
++ l = MIN(n,MAX_FUNC_NAME_LEN);
++ if (copy_from_user (command, buf, l)) {
++ count = -EFAULT;
++ }
++ else {
++ if (l > 0 && command[l-1] == '\n') {
++ l -= 1;
++ }
++ command[l] = 0;
++ n -= l;
++ // flush remainder, if any
++ while (n > 0) {
++ // Not too efficient, but it shouldn't matter
++ if (copy_from_user (&c, buf + (count - n), 1)) {
++ count = -EFAULT;
++ break;
++ }
++ n -= 1;
++ }
++ }
++ }
++
++ if (0 >= count) {
++ printk(KERN_INFO"%s: count <= 0 %d\n", __FUNCTION__, count);
++ return count;
++ }
++
++ //printk(KERN_INFO"%s: %s\n", __FUNCTION__, command);
++ if (!usbd_admin_procfs(command)) {
++ // do nothing
++ //printk(KERN_INFO"%s: back\n", __FUNCTION__);
++ }
++
++
++ /*
++ * debug - increment switch_debug
++ */
++ else if (!strncmp("debug", command, 5)) {
++ switch_debug++;
++ if (switch_debug)
++ printk(KERN_INFO"%s: debug: %d\n", __FUNCTION__, switch_debug);
++ }
++ /*
++ * nodebug - reset switch_debug
++ */
++ else if (!strncmp("nodebug", command, 7)) {
++ switch_debug = 0;
++ if (switch_debug)
++ printk(KERN_INFO"%s: no debug\n", __FUNCTION__);
++ }
++
++ return count;
++}
++
++/* usbd_proc_switch_read - implement proc file system read.
++ * Standard proc file system read function.
++ */
++static ssize_t usbd_proc_switch_read (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len;
++ //int index;
++ char *bp,*ep;
++ struct list_head *lhd;
++
++ if ((*pos)++ > 0) {
++ /* This is the second time, we finished on the first time,
++ indicate we have no more data by returning 0. */
++ return(0);
++ }
++
++ // get a page, max 4095 bytes of data...
++ if (!(page = get_free_page (GFP_KERNEL))) {
++ return -ENOMEM;
++ }
++
++ bp = (char *) page;
++ ep = bp + 4095;
++
++ bp += sprintf(bp, "USB cable ");
++ if (NULL != usbd_bus_instance &&
++ NULL != usbd_bus_instance->driver &&
++ NULL != usbd_bus_instance->driver->bops &&
++ NULL != usbd_bus_instance->driver->bops->bus_attached &&
++ usbd_bus_instance->driver->bops->bus_attached(usbd_bus_instance)) {
++ bp += sprintf(bp, "at");
++ } else {
++ bp += sprintf(bp, "de");
++ }
++ bp += sprintf(bp, "tached");
++ bp += sprintf(bp, ", USB pullup resistor ");
++ if (NULL != usbd_bus_instance &&
++ NULL != usbd_bus_instance->driver &&
++ NULL != usbd_bus_instance->driver->bops &&
++ NULL != usbd_bus_instance->driver->bops->bus_connected &&
++ !usbd_bus_instance->driver->bops->bus_connected(usbd_bus_instance)) {
++ bp += sprintf(bp, "dis");
++ }
++ bp += sprintf(bp, "connected");
++ bp += sprintf(bp, "\nUSB Device function drivers:\n");
++ list_for_each (lhd, &usbd_function_drivers) {
++ struct usb_function_driver *fd = list_entry(lhd, struct usb_function_driver, drivers);
++ char enabled = '-';
++ if (usbd_bus_instance && usbd_bus_instance->function_instance &&
++ usbd_bus_instance->function_instance->function_driver == fd) {
++ enabled = '+';
++ }
++ if ((ep - bp) < 64) {
++ printk(KERN_INFO"%s: Too many usbd functions!\n", __FUNCTION__);
++ break;
++ }
++ bp += sprintf(bp," %c [%s]\n",enabled,fd->name);
++ }
++ len = bp - (char *) page;
++
++ if (len > 0 && copy_to_user (buf, (char *) page, len)) {
++ //printk(KERN_INFO"%s: EFAULT\n", __FUNCTION__);
++ len = -EFAULT;
++ } else {
++ //printk(KERN_INFO"%s: OK\n", __FUNCTION__);
++ }
++ free_page (page);
++ return len;
++}
++
++static struct file_operations usbd_proc_switch_functions = {
++ write:usbd_proc_switch_write,
++ read:usbd_proc_switch_read,
++};
++#endif
++
++
++/* ******************************************************************************************* */
++
++#if defined(CONFIG_PM)
++/* switch_pm_event
++ *
++ * Handle power management event
++ */
++static int switch_pm_event (struct pm_dev *dev, pm_request_t rqst, void *unused)
++{
++ switch (rqst) {
++ case PM_SUSPEND:
++ usbd_pm_off(usbd_load_arg);
++ break;
++ case PM_RESUME:
++ usbd_pm_on(usbd_load_arg);
++ break;
++ }
++ return 0;
++}
++#endif
++
++/* ******************************************************************************************* */
++
++
++
++/* ******************************************************************************************* */
++
++#if defined(CONFIG_PM)
++struct pm_dev *switch_pm_info;
++#endif
++
++/* usbd_switch_init
++ *
++ */
++int usbd_switch_init(void)
++{
++
++#ifdef CONFIG_USBD_PROCFS
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ //printk(KERN_INFO"%s: creating /proc/usbd-switch\n", __FUNCTION__);
++ if ((p = create_proc_entry ("usbd-switch", 0666, 0)) == NULL) {
++ printk(KERN_ERR"%s: creating /proc/usbd-switch failed\n", __FUNCTION__);
++ return -ENOMEM;
++ }
++ p->proc_fops = &usbd_proc_switch_functions;
++#endif
++#ifdef CONFIG_PM
++ switch_pm_info = NULL;
++
++ if (!(switch_pm_info = pm_register (PM_USB_DEV, PM_SYS_UNKNOWN, switch_pm_event)))
++ return -ENOMEM;
++
++ switch_pm_info->state = 0;
++#endif
++ enable_bh.routine = usbd_enable_bh;
++ enable_bh.data = NULL;
++ disable_bh.routine = usbd_disable_bh;
++ disable_bh.data = NULL;
++ return 0;
++}
++
++void usbd_switch_exit (void)
++{
++ // This is *only* used for drivers compiled and used as a module.
++#ifdef CONFIG_PM
++ if (switch_pm_info)
++ pm_unregister_all(switch_pm_event);
++ switch_pm_info = NULL;
++#endif
++#ifdef CONFIG_USBD_PROCFS
++ remove_proc_entry("usbd-switch", NULL);
++#endif
++ switch_exiting = 1;
++ while (enable_bh.sync || disable_bh.sync) {
++ printk(KERN_INFO"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++}
++
++
++
++/* Module init ******************************************************************************* */
++
++int usbd_switch_init(void);
++void usbd_switch_exit (void);
++
++static int usbd_device_init (void)
++{
++ printk (KERN_INFO "%s: %s %s\n", __FUNCTION__, __usbd_module_info, USBD_EXPORT_TAG);
++
++ usbd_switch_init();
++
++ return 0;
++}
++
++static void usbd_device_exit (void)
++{
++ //printk (KERN_INFO "%s: %s exiting\n", __FUNCTION__, __usbd_module_info);
++
++ usbd_switch_exit();
++
++ if ( usbd_load_arg)
++ lkfree(usbd_load_arg);
++
++#ifdef MALLOC_TEST
++ if (usbd_mallocs) printk(KERN_INFO"%s: usbd_mallocs non-zero! %d\n", __FUNCTION__, usbd_mallocs);
++#endif
++}
++
++module_init (usbd_device_init);
++module_exit (usbd_device_exit);
++
++EXPORT_SYMBOL(usbd_function_drivers);
++EXPORT_SYMBOL(usbd_maxstrings);
++
++EXPORT_SYMBOL(usbd_enable);
++EXPORT_SYMBOL(usbd_disable);
++EXPORT_SYMBOL(usbd_enable_irq);
++EXPORT_SYMBOL(usbd_disable_irq);
++
++EXPORT_SYMBOL(usbd_connect);
++EXPORT_SYMBOL(usbd_disconnect);
++EXPORT_SYMBOL(usbd_pm_on);
++EXPORT_SYMBOL(usbd_pm_off);
++
++EXPORT_SYMBOL(usbd_load);
++EXPORT_SYMBOL(usbd_unload);
++EXPORT_SYMBOL(usbd_unplug);
++EXPORT_SYMBOL(usbd_replug);
++
++
++EXPORT_SYMBOL(usbd_bus_instance);
++#ifdef MALLOC_TEST
++EXPORT_SYMBOL(usbd_mallocs);
++#endif
++
++
+diff -Nru a/drivers/usbd/usbd.h b/drivers/usbd/usbd.h
+--- /dev/null Wed Dec 31 16:00:00 1969
++++ b/drivers/usbd/usbd.h Fri Feb 27 14:22:51 2004
+@@ -0,0 +1,239 @@
++/*
++ * usbd/usbd.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * Adapted from earlier work:
++ * Copyright (c) 2002, 2003 Belcarra
++ * Copyright (c) 2000, 2001, 2002 Lineo
++ * Copyright (c) 2001 Hewlett Packard
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This program is free software; you can redistribute it and/or modify it under the terms of
++ * the GNU General Public License as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
++ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ * See the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License along with this program; if
++ * not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++/*
++ * This file contains the USB Device Core Common definitions. It also contains definitions for
++ * functions that are commonly used by both Function Drivers and Bus Interface Drivers.
++ *
++ * Specifically:
++ *
++ * o public functions exported by the USB Core layer
++ *
++ * o common structures and definitions
++ *
++ */
++
++
++/*
++ * Device Events
++ *
++ * These are defined in the USB Spec (c.f USB Spec 2.0 Figure 9-1).
++ *
++ * There are additional events defined to handle some extra actions we need to have handled.
++ *
++ */
++typedef enum usb_device_event {
++
++ DEVICE_UNKNOWN, // bi - unknown event
++ DEVICE_INIT, // bi - initialize
++ DEVICE_CREATE, // bi -
++ DEVICE_HUB_CONFIGURED, // bi - bus has been plugged int
++ DEVICE_RESET, // bi - hub has powered our port
++
++ DEVICE_ADDRESS_ASSIGNED,// ep0 - set address setup received
++ DEVICE_CONFIGURED, // ep0 - set configure setup received
++ DEVICE_SET_INTERFACE, // ep0 - set interface setup received
++
++ DEVICE_SET_FEATURE, // ep0 - set feature setup received
++ DEVICE_CLEAR_FEATURE, // ep0 - clear feature setup received
++
++ DEVICE_DE_CONFIGURED, // ep0 - set configure setup received for ??
++
++ DEVICE_BUS_INACTIVE, // bi - bus in inactive (no SOF packets)
++ DEVICE_BUS_ACTIVITY, // bi - bus is active again
++
++ DEVICE_POWER_INTERRUPTION,// bi - hub has depowered our port
++ DEVICE_HUB_RESET, // bi - bus has been unplugged
++ DEVICE_DESTROY, // bi - device instance should be destroyed
++ DEVICE_CLOSE, // bi - device instance should be destroyed
++
++} usb_device_event_t;
++
++
++
++struct usb_bus_instance;
++struct usb_function_instance;
++
++typedef struct urb_link {
++ struct urb_link *next;
++ struct urb_link *prev;
++} urb_link;
++
++/* URB Status
++ *
++ */
++typedef enum usbd_urb_status {
++ SEND_IN_QUEUE,
++ SEND_IN_PROGRESS,
++ SEND_FINISHED_OK,
++ SEND_FINISHED_ERROR,
++ SEND_FINISHED_CANCELLED,
++ RECV_IN_QUEUE,
++ RECV_IN_PROGRESS,
++ RECV_OK,
++ RECV_ERROR,
++ RECV_CANCELLED
++} usbd_urb_status_t;
++
++
++
++/* USB Data structure
++ *
++ * This is used for both sending and receiving data.
++ *
++ * The callback function is used to let the function driver know when transmitted data has been
++ * sent.
++ *
++ * The callback function is set by the alloc_recv function when an urb is allocated for
++ * receiving data for an endpoint and used to call the function driver to inform it that data
++ * has arrived.
++ *
++ * Note that for OUT urbs the buffer is always allocated to a multiple of the packetsize that is
++ * 1 larger than the requested size. This prevents overflow if the host unexpectedly sends a
++ * full sized packet when we are expecting a short one (the host is always right..)
++ */
++
++struct urb {
++
++ struct usb_bus_instance *bus;
++ struct usb_function_instance *function_instance;
++ struct usb_endpoint_instance *endpoint;
++
++ int (*callback) (struct urb *, int);
++
++ u8 *buffer; // data received (OUT) or being sent (IN)
++ u32 request_length; // maximum data expected for OUT
++ u32 buffer_length; // allocated size of buffer
++ u32 actual_length; // actual data received (OUT or being sent (IN)
++ u32 flags;
++
++ void *privdata;
++
++ struct urb_link link;
++ usbd_urb_status_t status; // what is the current status of the urb
++ time_t jiffies; // timestamp for when urb was started or finished
++ u16 framenum; // SOF framenum when urb was finished
++};
++
++#define USBD_URB_SENDZLP 0x01
++
++
++/*
++ * Device State (c.f USB Spec 2.0 Figure 9-1)
++ *
++ * What state the usb device is in.
++ *
++ * Note the state does not change if the device is suspended, we simply set a
++ * flag to show that it is suspended.
++ *
++ */
++typedef enum usb_device_state {
++ STATE_INIT, // just initialized
++ STATE_CREATED, // just created
++ STATE_ATTACHED, // we are attached
++ STATE_POWERED, // we have seen power indication (electrical bus signal)
++ STATE_DEFAULT, // we been reset
++ STATE_ADDRESSED, // we have been addressed (in default configuration)
++ STATE_CONFIGURED, // we have seen a set configuration device command
++ STATE_SUSPENDED,
++ STATE_UNKNOWN, // destroyed
++} usb_device_state_t;
++
++/*
++ * Device status
++ *
++ * Overall state
++ */
++typedef enum usb_device_status {
++ USBD_OPENING, // we are currently opening
++ USBD_RESETING, // we are currently opening
++ USBD_OK, // ok to use
++ USBD_SUSPENDED, // we are currently suspended
++ USBD_CLOSING, // we are currently closing
++ USBD_CLOSED, // we are currently closing
++ USBD_UNKNOWN,
++} usb_device_status_t;
++
++/*
++ * Bus state
++ *
++ * enabled or disabled
++ */
++typedef enum usbd_bus_state {
++ usbd_bus_state_unknown,
++ usbd_bus_state_disabled,
++ usbd_bus_state_enabled
++} usbd_bus_state_t;
++
++
++
++/* Endpoint Request
++ *
++ * An array of these structures is initialized by each function driver to specify the endpoints
++ * it requires.
++ *
++ * The bus interface driver will attempt to fulfill these requests with the actual endpoints it
++ * has available.
++ *
++ * Note that in most cases the bEndpointAddress should be left as zero except for specialized
++ * function drivers that both require a specific value and know ahead of time that the specified
++ * value is legal for the bus interface driver being used.
++ */
++struct usb_endpoint_request {
++ u8 configuration; // configuration endpoint will be in
++ u8 interface; // interface endpoint will be in
++ u8 alternate; // altsetting for this request
++ u8 bmAttributes; // endpoint type AND direction
++ u16 fs_requestedTransferSize; // max full speed transfer size for this endpoint
++ u16 hs_requestedTransferSize; // max high speed transfer size for this endpoint
++ u8 bEndpointAddress; // specific bEndpointAddress function driver requires
++ u8 physical; // physical endpoint used
++};
++
++
++
++struct usb_function_operations;
++struct usb_function_driver;
++
++
++
++/*
++ * USB Bus Interface Driver structures
++ *
++ * Driver description:
++ *
++ * struct usb_bus_operations
++ * struct usb_bus_driver
++ *
++ */
++
++struct usb_bus_operations;
++struct usb_bus_driver;
++extern int usbd_maxstrings;
++
++
git.openpandora.org / openembedded.git / commitdiff